mb89352.c revision 1.27
1 /* $NetBSD: mb89352.c,v 1.27 2004/08/07 07:17:09 tsutsui Exp $ */ 2 /* NecBSD: mb89352.c,v 1.4 1998/03/14 07:31:20 kmatsuda Exp */ 3 4 /*- 5 * Copyright (c) 1996,97,98,99 The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Charles M. Hannum, Masaru Oki and Kouichi Matsuda. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by Charles M. Hannum. 22 * 4. The name of the author may not be used to endorse or promote products 23 * derived from this software without specific prior written permission. 24 * 25 * Copyright (c) 1994 Jarle Greipsland 26 * All rights reserved. 27 * 28 * Redistribution and use in source and binary forms, with or without 29 * modification, are permitted provided that the following conditions 30 * are met: 31 * 1. Redistributions of source code must retain the above copyright 32 * notice, this list of conditions and the following disclaimer. 33 * 2. Redistributions in binary form must reproduce the above copyright 34 * notice, this list of conditions and the following disclaimer in the 35 * documentation and/or other materials provided with the distribution. 36 * 3. The name of the author may not be used to endorse or promote products 37 * derived from this software without specific prior written permission. 38 * 39 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 40 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 41 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 42 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 43 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 44 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 45 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 46 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 47 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 48 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 49 * POSSIBILITY OF SUCH DAMAGE. 50 */ 51 /* 52 * [NetBSD for NEC PC-98 series] 53 * Copyright (c) 1996, 1997, 1998 54 * NetBSD/pc98 porting staff. All rights reserved. 55 * Copyright (c) 1996, 1997, 1998 56 * Kouichi Matsuda. All rights reserved. 57 */ 58 59 /* 60 * Acknowledgements: Many of the algorithms used in this driver are 61 * inspired by the work of Julian Elischer (julian (at) tfs.com) and 62 * Charles Hannum (mycroft (at) duality.gnu.ai.mit.edu). Thanks a million! 63 */ 64 65 /* TODO list: 66 * 1) Get the DMA stuff working. 67 * 2) Get the iov/uio stuff working. Is this a good thing ??? 68 * 3) Get the synch stuff working. 69 * 4) Rewrite it to use malloc for the acb structs instead of static alloc.? 70 */ 71 72 #include <sys/cdefs.h> 73 __KERNEL_RCSID(0, "$NetBSD: mb89352.c,v 1.27 2004/08/07 07:17:09 tsutsui Exp $"); 74 75 #ifdef DDB 76 #define integrate 77 #else 78 #define integrate __inline static 79 #endif 80 81 /* 82 * A few customizable items: 83 */ 84 85 /* Synchronous data transfers? */ 86 #define SPC_USE_SYNCHRONOUS 0 87 #define SPC_SYNC_REQ_ACK_OFS 8 88 89 /* Wide data transfers? */ 90 #define SPC_USE_WIDE 0 91 #define SPC_MAX_WIDTH 0 92 93 /* Max attempts made to transmit a message */ 94 #define SPC_MSG_MAX_ATTEMPT 3 /* Not used now XXX */ 95 96 /* 97 * Some spin loop parameters (essentially how long to wait some places) 98 * The problem(?) is that sometimes we expect either to be able to transmit a 99 * byte or to get a new one from the SCSI bus pretty soon. In order to avoid 100 * returning from the interrupt just to get yanked back for the next byte we 101 * may spin in the interrupt routine waiting for this byte to come. How long? 102 * This is really (SCSI) device and processor dependent. Tuneable, I guess. 103 */ 104 #define SPC_MSGIN_SPIN 1 /* Will spinwait upto ?ms for a new msg byte */ 105 #define SPC_MSGOUT_SPIN 1 106 107 /* 108 * Include debug functions? At the end of this file there are a bunch of 109 * functions that will print out various information regarding queued SCSI 110 * commands, driver state and chip contents. You can call them from the 111 * kernel debugger. If you set SPC_DEBUG to 0 they are not included (the 112 * kernel uses less memory) but you lose the debugging facilities. 113 */ 114 #if 0 115 #define SPC_DEBUG 1 116 #endif 117 118 #define SPC_ABORT_TIMEOUT 2000 /* time to wait for abort */ 119 120 /* threshold length for DMA transfer */ 121 #define SPC_MIN_DMA_LEN 32 122 123 #ifdef x68k /* XXX it seems x68k SPC SCSI hardware has some quirks */ 124 #define NEED_DREQ_ON_HARDWARE_XFER 125 #define NO_MANUAL_XFER 126 #endif 127 128 /* End of customizable parameters */ 129 130 /* 131 * MB89352 SCSI Protocol Controller (SPC) routines. 132 */ 133 134 #include "opt_ddb.h" 135 136 #include <sys/param.h> 137 #include <sys/systm.h> 138 #include <sys/kernel.h> 139 #include <sys/errno.h> 140 #include <sys/ioctl.h> 141 #include <sys/device.h> 142 #include <sys/buf.h> 143 #include <sys/proc.h> 144 #include <sys/user.h> 145 #include <sys/queue.h> 146 147 #include <machine/intr.h> 148 #include <machine/bus.h> 149 150 #include <dev/scsipi/scsi_all.h> 151 #include <dev/scsipi/scsipi_all.h> 152 #include <dev/scsipi/scsi_message.h> 153 #include <dev/scsipi/scsiconf.h> 154 155 #include <dev/ic/mb89352reg.h> 156 #include <dev/ic/mb89352var.h> 157 158 #ifndef DDB 159 #define Debugger() panic("should call debugger here (mb89352.c)") 160 #endif /* ! DDB */ 161 162 #if SPC_DEBUG 163 int spc_debug = 0x00; /* SPC_SHOWSTART|SPC_SHOWMISC|SPC_SHOWTRACE; */ 164 #endif 165 166 void spc_done __P((struct spc_softc *, struct spc_acb *)); 167 void spc_dequeue __P((struct spc_softc *, struct spc_acb *)); 168 void spc_scsipi_request __P((struct scsipi_channel *, 169 scsipi_adapter_req_t, void *)); 170 int spc_poll __P((struct spc_softc *, struct scsipi_xfer *, int)); 171 integrate void spc_sched_msgout __P((struct spc_softc *, u_char)); 172 integrate void spc_setsync __P((struct spc_softc *, struct spc_tinfo *)); 173 void spc_select __P((struct spc_softc *, struct spc_acb *)); 174 void spc_timeout __P((void *)); 175 void spc_scsi_reset __P((struct spc_softc *)); 176 void spc_reset __P((struct spc_softc *)); 177 void spc_free_acb __P((struct spc_softc *, struct spc_acb *, int)); 178 struct spc_acb* spc_get_acb __P((struct spc_softc *)); 179 int spc_reselect __P((struct spc_softc *, int)); 180 void spc_msgin __P((struct spc_softc *)); 181 void spc_abort __P((struct spc_softc *, struct spc_acb *)); 182 void spc_msgout __P((struct spc_softc *)); 183 int spc_dataout_pio __P((struct spc_softc *, u_char *, int)); 184 int spc_datain_pio __P((struct spc_softc *, u_char *, int)); 185 #if SPC_DEBUG 186 void spc_print_acb __P((struct spc_acb *)); 187 void spc_dump_driver __P((struct spc_softc *)); 188 void spc_dump89352 __P((struct spc_softc *)); 189 void spc_show_scsi_cmd __P((struct spc_acb *)); 190 void spc_print_active_acb __P((void)); 191 #endif 192 193 extern struct cfdriver spc_cd; 194 195 /* 196 * INITIALIZATION ROUTINES (probe, attach ++) 197 */ 198 199 /* 200 * Do the real search-for-device. 201 * Prerequisite: sc->sc_iobase should be set to the proper value 202 */ 203 int 204 spc_find(iot, ioh, bdid) 205 bus_space_tag_t iot; 206 bus_space_handle_t ioh; 207 int bdid; 208 { 209 long timeout = SPC_ABORT_TIMEOUT; 210 211 SPC_TRACE(("spc: probing for spc-chip\n")); 212 /* 213 * Disable interrupts then reset the FUJITSU chip. 214 */ 215 bus_space_write_1(iot, ioh, SCTL, SCTL_DISABLE | SCTL_CTRLRST); 216 bus_space_write_1(iot, ioh, SCMD, 0); 217 bus_space_write_1(iot, ioh, PCTL, 0); 218 bus_space_write_1(iot, ioh, TEMP, 0); 219 bus_space_write_1(iot, ioh, TCH, 0); 220 bus_space_write_1(iot, ioh, TCM, 0); 221 bus_space_write_1(iot, ioh, TCL, 0); 222 bus_space_write_1(iot, ioh, INTS, 0); 223 bus_space_write_1(iot, ioh, SCTL, 224 SCTL_DISABLE | SCTL_ABRT_ENAB | SCTL_PARITY_ENAB | SCTL_RESEL_ENAB); 225 bus_space_write_1(iot, ioh, BDID, bdid); 226 delay(400); 227 bus_space_write_1(iot, ioh, SCTL, 228 bus_space_read_1(iot, ioh, SCTL) & ~SCTL_DISABLE); 229 230 /* The following detection is derived from spc.c 231 * (by Takahide Matsutsuka) in FreeBSD/pccard-test. 232 */ 233 while (bus_space_read_1(iot, ioh, PSNS) && timeout) { 234 timeout--; 235 DELAY(1); 236 } 237 if (timeout == 0) { 238 printf("spc: find failed\n"); 239 return 0; 240 } 241 242 SPC_START(("SPC found")); 243 return 1; 244 } 245 246 void 247 spc_attach(sc) 248 struct spc_softc *sc; 249 { 250 251 SPC_TRACE(("spc_attach ")); 252 sc->sc_state = SPC_INIT; 253 254 sc->sc_freq = 20; /* XXXX Assume 20 MHz. */ 255 256 #if SPC_USE_SYNCHRONOUS 257 /* 258 * These are the bounds of the sync period, based on the frequency of 259 * the chip's clock input and the size and offset of the sync period 260 * register. 261 * 262 * For a 20MHz clock, this gives us 25, or 100nS, or 10MB/s, as a 263 * maximum transfer rate, and 112.5, or 450nS, or 2.22MB/s, as a 264 * minimum transfer rate. 265 */ 266 sc->sc_minsync = (2 * 250) / sc->sc_freq; 267 sc->sc_maxsync = (9 * 250) / sc->sc_freq; 268 #endif 269 270 spc_init(sc); /* Init chip and driver */ 271 272 /* 273 * Fill in the adapter. 274 */ 275 sc->sc_adapter.adapt_dev = &sc->sc_dev; 276 sc->sc_adapter.adapt_nchannels = 1; 277 sc->sc_adapter.adapt_openings = 7; 278 sc->sc_adapter.adapt_max_periph = 1; 279 sc->sc_adapter.adapt_minphys = minphys; 280 sc->sc_adapter.adapt_request = spc_scsipi_request; 281 282 sc->sc_channel.chan_adapter = &sc->sc_adapter; 283 sc->sc_channel.chan_bustype = &scsi_bustype; 284 sc->sc_channel.chan_channel = 0; 285 sc->sc_channel.chan_ntargets = 8; 286 sc->sc_channel.chan_nluns = 8; 287 sc->sc_channel.chan_id = sc->sc_initiator; 288 289 /* 290 * ask the adapter what subunits are present 291 */ 292 config_found(&sc->sc_dev, &sc->sc_channel, scsiprint); 293 } 294 295 /* 296 * Initialize MB89352 chip itself 297 * The following conditions should hold: 298 * spc_isa_probe should have succeeded, i.e. the iobase address in spc_softc 299 * must be valid. 300 */ 301 void 302 spc_reset(sc) 303 struct spc_softc *sc; 304 { 305 bus_space_tag_t iot = sc->sc_iot; 306 bus_space_handle_t ioh = sc->sc_ioh; 307 308 SPC_TRACE(("spc_reset ")); 309 /* 310 * Disable interrupts then reset the FUJITSU chip. 311 */ 312 bus_space_write_1(iot, ioh, SCTL, SCTL_DISABLE | SCTL_CTRLRST); 313 bus_space_write_1(iot, ioh, SCMD, 0); 314 bus_space_write_1(iot, ioh, TMOD, 0); 315 bus_space_write_1(iot, ioh, PCTL, 0); 316 bus_space_write_1(iot, ioh, TEMP, 0); 317 bus_space_write_1(iot, ioh, TCH, 0); 318 bus_space_write_1(iot, ioh, TCM, 0); 319 bus_space_write_1(iot, ioh, TCL, 0); 320 bus_space_write_1(iot, ioh, INTS, 0); 321 bus_space_write_1(iot, ioh, SCTL, 322 SCTL_DISABLE | SCTL_ABRT_ENAB | SCTL_PARITY_ENAB | SCTL_RESEL_ENAB); 323 bus_space_write_1(iot, ioh, BDID, sc->sc_initiator); 324 delay(400); 325 bus_space_write_1(iot, ioh, SCTL, 326 bus_space_read_1(iot, ioh, SCTL) & ~SCTL_DISABLE); 327 } 328 329 330 /* 331 * Pull the SCSI RST line for 500us. 332 */ 333 void 334 spc_scsi_reset(sc) 335 struct spc_softc *sc; 336 { 337 bus_space_tag_t iot = sc->sc_iot; 338 bus_space_handle_t ioh = sc->sc_ioh; 339 340 SPC_TRACE(("spc_scsi_reset ")); 341 bus_space_write_1(iot, ioh, SCMD, 342 bus_space_read_1(iot, ioh, SCMD) | SCMD_RST); 343 delay(500); 344 bus_space_write_1(iot, ioh, SCMD, 345 bus_space_read_1(iot, ioh, SCMD) & ~SCMD_RST); 346 delay(50); 347 } 348 349 /* 350 * Initialize spc SCSI driver. 351 */ 352 void 353 spc_init(sc) 354 struct spc_softc *sc; 355 { 356 struct spc_acb *acb; 357 int r; 358 359 SPC_TRACE(("spc_init ")); 360 spc_reset(sc); 361 spc_scsi_reset(sc); 362 spc_reset(sc); 363 364 if (sc->sc_state == SPC_INIT) { 365 /* First time through; initialize. */ 366 TAILQ_INIT(&sc->ready_list); 367 TAILQ_INIT(&sc->nexus_list); 368 TAILQ_INIT(&sc->free_list); 369 sc->sc_nexus = NULL; 370 acb = sc->sc_acb; 371 memset(acb, 0, sizeof(sc->sc_acb)); 372 for (r = 0; r < sizeof(sc->sc_acb) / sizeof(*acb); r++) { 373 TAILQ_INSERT_TAIL(&sc->free_list, acb, chain); 374 acb++; 375 } 376 memset(&sc->sc_tinfo, 0, sizeof(sc->sc_tinfo)); 377 } else { 378 /* Cancel any active commands. */ 379 sc->sc_state = SPC_CLEANING; 380 if ((acb = sc->sc_nexus) != NULL) { 381 acb->xs->error = XS_DRIVER_STUFFUP; 382 callout_stop(&acb->xs->xs_callout); 383 spc_done(sc, acb); 384 } 385 while ((acb = TAILQ_FIRST(&sc->nexus_list)) != NULL) { 386 acb->xs->error = XS_DRIVER_STUFFUP; 387 callout_stop(&acb->xs->xs_callout); 388 spc_done(sc, acb); 389 } 390 } 391 392 sc->sc_prevphase = PH_INVALID; 393 for (r = 0; r < 8; r++) { 394 struct spc_tinfo *ti = &sc->sc_tinfo[r]; 395 396 ti->flags = 0; 397 #if SPC_USE_SYNCHRONOUS 398 ti->flags |= DO_SYNC; 399 ti->period = sc->sc_minsync; 400 ti->offset = SPC_SYNC_REQ_ACK_OFS; 401 #else 402 ti->period = ti->offset = 0; 403 #endif 404 #if SPC_USE_WIDE 405 ti->flags |= DO_WIDE; 406 ti->width = SPC_MAX_WIDTH; 407 #else 408 ti->width = 0; 409 #endif 410 } 411 412 sc->sc_state = SPC_IDLE; 413 bus_space_write_1(sc->sc_iot, sc->sc_ioh, SCTL, 414 bus_space_read_1(sc->sc_iot, sc->sc_ioh, SCTL) | SCTL_INTR_ENAB); 415 } 416 417 void 418 spc_free_acb(sc, acb, flags) 419 struct spc_softc *sc; 420 struct spc_acb *acb; 421 int flags; 422 { 423 int s; 424 425 SPC_TRACE(("spc_free_acb ")); 426 s = splbio(); 427 428 acb->flags = 0; 429 TAILQ_INSERT_HEAD(&sc->free_list, acb, chain); 430 splx(s); 431 } 432 433 struct spc_acb * 434 spc_get_acb(sc) 435 struct spc_softc *sc; 436 { 437 struct spc_acb *acb; 438 int s; 439 440 SPC_TRACE(("spc_get_acb ")); 441 s = splbio(); 442 acb = TAILQ_FIRST(&sc->free_list); 443 if (acb != NULL) { 444 TAILQ_REMOVE(&sc->free_list, acb, chain); 445 acb->flags |= ACB_ALLOC; 446 } 447 splx(s); 448 return acb; 449 } 450 451 /* 452 * DRIVER FUNCTIONS CALLABLE FROM HIGHER LEVEL DRIVERS 453 */ 454 455 /* 456 * Expected sequence: 457 * 1) Command inserted into ready list 458 * 2) Command selected for execution 459 * 3) Command won arbitration and has selected target device 460 * 4) Send message out (identify message, eventually also sync.negotiations) 461 * 5) Send command 462 * 5a) Receive disconnect message, disconnect. 463 * 5b) Reselected by target 464 * 5c) Receive identify message from target. 465 * 6) Send or receive data 466 * 7) Receive status 467 * 8) Receive message (command complete etc.) 468 */ 469 470 /* 471 * Start a SCSI-command 472 * This function is called by the higher level SCSI-driver to queue/run 473 * SCSI-commands. 474 */ 475 void 476 spc_scsipi_request(chan, req, arg) 477 struct scsipi_channel *chan; 478 scsipi_adapter_req_t req; 479 void *arg; 480 { 481 struct scsipi_xfer *xs; 482 struct scsipi_periph *periph; 483 struct spc_softc *sc = (void *)chan->chan_adapter->adapt_dev; 484 struct spc_acb *acb; 485 int s, flags; 486 487 switch (req) { 488 case ADAPTER_REQ_RUN_XFER: 489 xs = arg; 490 periph = xs->xs_periph; 491 SPC_TRACE(("spc_scsipi_request ")); 492 SPC_CMDS(("[0x%x, %d]->%d ", (int)xs->cmd->opcode, xs->cmdlen, 493 periph->periph_target)); 494 495 flags = xs->xs_control; 496 acb = spc_get_acb(sc); 497 #ifdef DIAGNOSTIC 498 /* 499 * This should nerver happen as we track the resources 500 * in the mid-layer. 501 */ 502 if (acb == NULL) { 503 scsipi_printaddr(periph); 504 printf("unable to allocate acb\n"); 505 panic("spc_scsipi_request"); 506 } 507 #endif 508 509 /* Initialize acb */ 510 acb->xs = xs; 511 acb->timeout = xs->timeout; 512 513 if (xs->xs_control & XS_CTL_RESET) { 514 acb->flags |= ACB_RESET; 515 acb->scsipi_cmd_length = 0; 516 acb->data_length = 0; 517 } else { 518 memcpy(&acb->scsipi_cmd, xs->cmd, xs->cmdlen); 519 acb->scsipi_cmd_length = xs->cmdlen; 520 acb->data_addr = xs->data; 521 acb->data_length = xs->datalen; 522 } 523 acb->target_stat = 0; 524 525 s = splbio(); 526 527 TAILQ_INSERT_TAIL(&sc->ready_list, acb, chain); 528 /* 529 * Start scheduling unless a queue process is in progress. 530 */ 531 if (sc->sc_state == SPC_IDLE) 532 spc_sched(sc); 533 /* 534 * After successful sending, check if we should return just now. 535 * If so, return SUCCESSFULLY_QUEUED. 536 */ 537 538 splx(s); 539 540 if ((flags & XS_CTL_POLL) == 0) 541 return; 542 543 /* Not allowed to use interrupts, use polling instead */ 544 s = splbio(); 545 if (spc_poll(sc, xs, acb->timeout)) { 546 spc_timeout(acb); 547 if (spc_poll(sc, xs, acb->timeout)) 548 spc_timeout(acb); 549 } 550 splx(s); 551 return; 552 case ADAPTER_REQ_GROW_RESOURCES: 553 /* XXX Not supported. */ 554 return; 555 case ADAPTER_REQ_SET_XFER_MODE: 556 { 557 /* 558 * We don't support Sync, Wide, or Tagged Command Queuing. 559 * Just callback now, to report this. 560 */ 561 struct scsipi_xfer_mode *xm = arg; 562 563 xm->xm_mode = 0; 564 xm->xm_period = 0; 565 xm->xm_offset = 0; 566 scsipi_async_event(chan, ASYNC_EVENT_XFER_MODE, xm); 567 return; 568 } 569 } 570 } 571 572 /* 573 * Used when interrupt driven I/O isn't allowed, e.g. during boot. 574 */ 575 int 576 spc_poll(sc, xs, count) 577 struct spc_softc *sc; 578 struct scsipi_xfer *xs; 579 int count; 580 { 581 bus_space_tag_t iot = sc->sc_iot; 582 bus_space_handle_t ioh = sc->sc_ioh; 583 584 SPC_TRACE(("spc_poll ")); 585 while (count) { 586 /* 587 * If we had interrupts enabled, would we 588 * have got an interrupt? 589 */ 590 if (bus_space_read_1(iot, ioh, INTS) != 0) 591 spc_intr(sc); 592 if ((xs->xs_status & XS_STS_DONE) != 0) 593 return 0; 594 delay(1000); 595 count--; 596 } 597 return 1; 598 } 599 600 /* 601 * LOW LEVEL SCSI UTILITIES 602 */ 603 604 integrate void 605 spc_sched_msgout(sc, m) 606 struct spc_softc *sc; 607 u_char m; 608 { 609 bus_space_tag_t iot = sc->sc_iot; 610 bus_space_handle_t ioh = sc->sc_ioh; 611 612 SPC_TRACE(("spc_sched_msgout ")); 613 if (sc->sc_msgpriq == 0) 614 bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ATN); 615 sc->sc_msgpriq |= m; 616 } 617 618 /* 619 * Set synchronous transfer offset and period. 620 */ 621 integrate void 622 spc_setsync(sc, ti) 623 struct spc_softc *sc; 624 struct spc_tinfo *ti; 625 { 626 #if SPC_USE_SYNCHRONOUS 627 bus_space_tag_t iot = sc->sc_iot; 628 bus_space_handle_t ioh = sc->sc_ioh; 629 630 SPC_TRACE(("spc_setsync ")); 631 if (ti->offset != 0) 632 bus_space_write_1(iot, ioh, TMOD, 633 ((ti->period * sc->sc_freq) / 250 - 2) << 4 | ti->offset); 634 else 635 bus_space_write_1(iot, ioh, TMOD, 0); 636 #endif 637 } 638 639 /* 640 * Start a selection. This is used by spc_sched() to select an idle target. 641 */ 642 void 643 spc_select(sc, acb) 644 struct spc_softc *sc; 645 struct spc_acb *acb; 646 { 647 struct scsipi_periph *periph = acb->xs->xs_periph; 648 int target = periph->periph_target; 649 struct spc_tinfo *ti = &sc->sc_tinfo[target]; 650 bus_space_tag_t iot = sc->sc_iot; 651 bus_space_handle_t ioh = sc->sc_ioh; 652 653 SPC_TRACE(("spc_select ")); 654 spc_setsync(sc, ti); 655 656 #if 0 657 bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ATN); 658 #endif 659 660 bus_space_write_1(iot, ioh, PCTL, 0); 661 bus_space_write_1(iot, ioh, TEMP, 662 (1 << sc->sc_initiator) | (1 << target)); 663 /* 664 * Setup BSY timeout (selection timeout). 665 * 250ms according to the SCSI specification. 666 * T = (X * 256 + 15) * Tclf * 2 (Tclf = 200ns on x68k) 667 * To setup 256ms timeout, 668 * 128000ns/200ns = X * 256 + 15 669 * 640 - 15 = X * 256 670 * X = 625 / 256 671 * X = 2 + 113 / 256 672 * ==> tch = 2, tcm = 113 (correct?) 673 */ 674 /* Time to the information transfer phase start. */ 675 /* XXX These values should be calculated from sc_freq */ 676 bus_space_write_1(iot, ioh, TCH, 2); 677 bus_space_write_1(iot, ioh, TCM, 113); 678 bus_space_write_1(iot, ioh, TCL, 3); 679 bus_space_write_1(iot, ioh, SCMD, SCMD_SELECT); 680 681 sc->sc_state = SPC_SELECTING; 682 } 683 684 int 685 spc_reselect(sc, message) 686 struct spc_softc *sc; 687 int message; 688 { 689 u_char selid, target, lun; 690 struct spc_acb *acb; 691 struct scsipi_periph *periph; 692 struct spc_tinfo *ti; 693 694 SPC_TRACE(("spc_reselect ")); 695 /* 696 * The SCSI chip made a snapshot of the data bus while the reselection 697 * was being negotiated. This enables us to determine which target did 698 * the reselect. 699 */ 700 selid = sc->sc_selid & ~(1 << sc->sc_initiator); 701 if (selid & (selid - 1)) { 702 printf("%s: reselect with invalid selid %02x; " 703 "sending DEVICE RESET\n", sc->sc_dev.dv_xname, selid); 704 SPC_BREAK(); 705 goto reset; 706 } 707 708 /* 709 * Search wait queue for disconnected cmd 710 * The list should be short, so I haven't bothered with 711 * any more sophisticated structures than a simple 712 * singly linked list. 713 */ 714 target = ffs(selid) - 1; 715 lun = message & 0x07; 716 TAILQ_FOREACH(acb, &sc->nexus_list, chain) { 717 periph = acb->xs->xs_periph; 718 if (periph->periph_target == target && 719 periph->periph_lun == lun) 720 break; 721 } 722 if (acb == NULL) { 723 printf("%s: reselect from target %d lun %d with no nexus; " 724 "sending ABORT\n", sc->sc_dev.dv_xname, target, lun); 725 SPC_BREAK(); 726 goto abort; 727 } 728 729 /* Make this nexus active again. */ 730 TAILQ_REMOVE(&sc->nexus_list, acb, chain); 731 sc->sc_state = SPC_CONNECTED; 732 sc->sc_nexus = acb; 733 ti = &sc->sc_tinfo[target]; 734 ti->lubusy |= (1 << lun); 735 spc_setsync(sc, ti); 736 737 if (acb->flags & ACB_RESET) 738 spc_sched_msgout(sc, SEND_DEV_RESET); 739 else if (acb->flags & ACB_ABORT) 740 spc_sched_msgout(sc, SEND_ABORT); 741 742 /* Do an implicit RESTORE POINTERS. */ 743 sc->sc_dp = acb->data_addr; 744 sc->sc_dleft = acb->data_length; 745 sc->sc_cp = (u_char *)&acb->scsipi_cmd; 746 sc->sc_cleft = acb->scsipi_cmd_length; 747 748 return (0); 749 750 reset: 751 spc_sched_msgout(sc, SEND_DEV_RESET); 752 return (1); 753 754 abort: 755 spc_sched_msgout(sc, SEND_ABORT); 756 return (1); 757 } 758 759 /* 760 * Schedule a SCSI operation. This has now been pulled out of the interrupt 761 * handler so that we may call it from spc_scsi_cmd and spc_done. This may 762 * save us an unnecessary interrupt just to get things going. Should only be 763 * called when state == SPC_IDLE and at bio pl. 764 */ 765 void 766 spc_sched(sc) 767 struct spc_softc *sc; 768 { 769 struct spc_acb *acb; 770 struct scsipi_periph *periph; 771 struct spc_tinfo *ti; 772 773 /* missing the hw, just return and wait for our hw */ 774 if (sc->sc_flags & SPC_INACTIVE) 775 return; 776 SPC_TRACE(("spc_sched ")); 777 /* 778 * Find first acb in ready queue that is for a target/lunit pair that 779 * is not busy. 780 */ 781 TAILQ_FOREACH(acb, &sc->ready_list, chain) { 782 periph = acb->xs->xs_periph; 783 ti = &sc->sc_tinfo[periph->periph_target]; 784 if ((ti->lubusy & (1 << periph->periph_lun)) == 0) { 785 SPC_MISC(("selecting %d:%d ", 786 periph->periph_target, periph->periph_lun)); 787 TAILQ_REMOVE(&sc->ready_list, acb, chain); 788 sc->sc_nexus = acb; 789 spc_select(sc, acb); 790 return; 791 } else 792 SPC_MISC(("%d:%d busy\n", 793 periph->periph_target, periph->periph_lun)); 794 } 795 SPC_MISC(("idle ")); 796 /* Nothing to start; just enable reselections and wait. */ 797 } 798 799 /* 800 * POST PROCESSING OF SCSI_CMD (usually current) 801 */ 802 void 803 spc_done(sc, acb) 804 struct spc_softc *sc; 805 struct spc_acb *acb; 806 { 807 struct scsipi_xfer *xs = acb->xs; 808 struct scsipi_periph *periph = xs->xs_periph; 809 struct spc_tinfo *ti = &sc->sc_tinfo[periph->periph_target]; 810 811 SPC_TRACE(("spc_done ")); 812 813 if (xs->error == XS_NOERROR) { 814 if (acb->flags & ACB_ABORT) { 815 xs->error = XS_DRIVER_STUFFUP; 816 } else { 817 switch (acb->target_stat) { 818 case SCSI_CHECK: 819 /* First, save the return values */ 820 xs->resid = acb->data_length; 821 /* FALLTHROUGH */ 822 case SCSI_BUSY: 823 xs->status = acb->target_stat; 824 xs->error = XS_BUSY; 825 break; 826 case SCSI_OK: 827 xs->resid = acb->data_length; 828 break; 829 default: 830 xs->error = XS_DRIVER_STUFFUP; 831 #if SPC_DEBUG 832 printf("%s: spc_done: bad stat 0x%x\n", 833 sc->sc_dev.dv_xname, acb->target_stat); 834 #endif 835 break; 836 } 837 } 838 } 839 840 #if SPC_DEBUG 841 if ((spc_debug & SPC_SHOWMISC) != 0) { 842 if (xs->resid != 0) 843 printf("resid=%d ", xs->resid); 844 else 845 printf("error=%d\n", xs->error); 846 } 847 #endif 848 849 /* 850 * Remove the ACB from whatever queue it happens to be on. 851 */ 852 if (acb->flags & ACB_NEXUS) 853 ti->lubusy &= ~(1 << periph->periph_lun); 854 if (acb == sc->sc_nexus) { 855 sc->sc_nexus = NULL; 856 sc->sc_state = SPC_IDLE; 857 spc_sched(sc); 858 } else 859 spc_dequeue(sc, acb); 860 861 spc_free_acb(sc, acb, xs->xs_control); 862 ti->cmds++; 863 scsipi_done(xs); 864 } 865 866 void 867 spc_dequeue(sc, acb) 868 struct spc_softc *sc; 869 struct spc_acb *acb; 870 { 871 872 SPC_TRACE(("spc_dequeue ")); 873 if (acb->flags & ACB_NEXUS) 874 TAILQ_REMOVE(&sc->nexus_list, acb, chain); 875 else 876 TAILQ_REMOVE(&sc->ready_list, acb, chain); 877 } 878 879 /* 880 * INTERRUPT/PROTOCOL ENGINE 881 */ 882 883 /* 884 * Precondition: 885 * The SCSI bus is already in the MSGI phase and there is a message byte 886 * on the bus, along with an asserted REQ signal. 887 */ 888 void 889 spc_msgin(sc) 890 struct spc_softc *sc; 891 { 892 bus_space_tag_t iot = sc->sc_iot; 893 bus_space_handle_t ioh = sc->sc_ioh; 894 int n; 895 u_int8_t msg; 896 897 SPC_TRACE(("spc_msgin ")); 898 899 if (sc->sc_prevphase == PH_MSGIN) { 900 /* This is a continuation of the previous message. */ 901 n = sc->sc_imp - sc->sc_imess; 902 goto nextbyte; 903 } 904 905 /* This is a new MESSAGE IN phase. Clean up our state. */ 906 sc->sc_flags &= ~SPC_DROP_MSGIN; 907 908 nextmsg: 909 n = 0; 910 sc->sc_imp = &sc->sc_imess[n]; 911 912 nextbyte: 913 /* 914 * Read a whole message, but don't ack the last byte. If we reject the 915 * message, we have to assert ATN during the message transfer phase 916 * itself. 917 */ 918 for (;;) { 919 #ifdef NO_MANUAL_XFER /* XXX */ 920 if (bus_space_read_1(iot, ioh, INTS) != 0) { 921 /* 922 * Target left MESSAGE IN, probably because it 923 * a) noticed our ATN signal, or 924 * b) ran out of messages. 925 */ 926 goto out; 927 } 928 #endif 929 /* If parity error, just dump everything on the floor. */ 930 if ((bus_space_read_1(iot, ioh, SERR) & 931 (SERR_SCSI_PAR|SERR_SPC_PAR)) != 0) { 932 sc->sc_flags |= SPC_DROP_MSGIN; 933 spc_sched_msgout(sc, SEND_PARITY_ERROR); 934 } 935 936 #ifdef NO_MANUAL_XFER /* XXX */ 937 /* send TRANSFER command. */ 938 bus_space_write_1(iot, ioh, TCH, 0); 939 bus_space_write_1(iot, ioh, TCM, 0); 940 bus_space_write_1(iot, ioh, TCL, 1); 941 bus_space_write_1(iot, ioh, PCTL, 942 sc->sc_phase | PCTL_BFINT_ENAB); 943 #ifdef NEED_DREQ_ON_HARDWARE_XFER 944 bus_space_write_1(iot, ioh, SCMD, SCMD_XFR); 945 #else 946 bus_space_write_1(iot, ioh, SCMD, SCMD_XFR | SCMD_PROG_XFR); 947 #endif 948 for (;;) { 949 if ((bus_space_read_1(iot, ioh, SSTS) & 950 SSTS_DREG_EMPTY) == 0) 951 break; 952 if (bus_space_read_1(iot, ioh, INTS) != 0) 953 goto out; 954 } 955 msg = bus_space_read_1(iot, ioh, DREG); 956 #else 957 if ((bus_space_read_1(iot, ioh, PSNS) & PSNS_ATN) != 0) 958 bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ATN); 959 960 while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) == 0) { 961 /* XXX needs timeout */ 962 if ((bus_space_read_1(iot, ioh, PSNS) & PH_MASK) 963 != PH_MSGIN) 964 /* 965 * Target left MESSAGE IN, probably because it 966 * a) noticed our ATN signal, or 967 * b) ran out of messages. 968 */ 969 goto out; 970 } 971 972 bus_space_write_1(iot, ioh, PCTL, PH_MSGIN); 973 msg = bus_space_read_1(iot, ioh, TEMP); 974 #endif 975 976 /* Gather incoming message bytes if needed. */ 977 if ((sc->sc_flags & SPC_DROP_MSGIN) == 0) { 978 if (n >= SPC_MAX_MSG_LEN) { 979 sc->sc_flags |= SPC_DROP_MSGIN; 980 spc_sched_msgout(sc, SEND_REJECT); 981 } else { 982 *sc->sc_imp++ = msg; 983 n++; 984 /* 985 * This testing is suboptimal, but most 986 * messages will be of the one byte variety, so 987 * it should not affect performance 988 * significantly. 989 */ 990 if (n == 1 && MSG_IS1BYTE(sc->sc_imess[0])) 991 break; 992 if (n == 2 && MSG_IS2BYTE(sc->sc_imess[0])) 993 break; 994 if (n >= 3 && MSG_ISEXTENDED(sc->sc_imess[0]) && 995 n == sc->sc_imess[1] + 2) 996 break; 997 } 998 } 999 /* 1000 * If we reach this spot we're either: 1001 * a) in the middle of a multi-byte message, or 1002 * b) dropping bytes. 1003 */ 1004 1005 #ifndef NO_MANUAL_XFER /* XXX */ 1006 /* Ack the last byte read. */ 1007 bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ACK); 1008 while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) != 0) 1009 continue; /* XXX needs timeout */ 1010 bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ACK); 1011 #endif 1012 } 1013 1014 SPC_MISC(("n=%d imess=0x%02x ", n, sc->sc_imess[0])); 1015 1016 /* We now have a complete message. Parse it. */ 1017 switch (sc->sc_state) { 1018 struct spc_acb *acb; 1019 struct scsipi_periph *periph; 1020 struct spc_tinfo *ti; 1021 1022 case SPC_CONNECTED: 1023 SPC_ASSERT(sc->sc_nexus != NULL); 1024 acb = sc->sc_nexus; 1025 ti = &sc->sc_tinfo[acb->xs->xs_periph->periph_target]; 1026 1027 switch (sc->sc_imess[0]) { 1028 case MSG_CMDCOMPLETE: 1029 if (sc->sc_dleft < 0) { 1030 periph = acb->xs->xs_periph; 1031 printf("%s: %d extra bytes from %d:%d\n", 1032 sc->sc_dev.dv_xname, -sc->sc_dleft, 1033 periph->periph_target, periph->periph_lun); 1034 sc->sc_dleft = 0; 1035 } 1036 acb->xs->resid = acb->data_length = sc->sc_dleft; 1037 sc->sc_state = SPC_CMDCOMPLETE; 1038 break; 1039 1040 case MSG_PARITY_ERROR: 1041 /* Resend the last message. */ 1042 spc_sched_msgout(sc, sc->sc_lastmsg); 1043 break; 1044 1045 case MSG_MESSAGE_REJECT: 1046 SPC_MISC(("message rejected %02x ", sc->sc_lastmsg)); 1047 switch (sc->sc_lastmsg) { 1048 #if SPC_USE_SYNCHRONOUS + SPC_USE_WIDE 1049 case SEND_IDENTIFY: 1050 ti->flags &= ~(DO_SYNC | DO_WIDE); 1051 ti->period = ti->offset = 0; 1052 spc_setsync(sc, ti); 1053 ti->width = 0; 1054 break; 1055 #endif 1056 #if SPC_USE_SYNCHRONOUS 1057 case SEND_SDTR: 1058 ti->flags &= ~DO_SYNC; 1059 ti->period = ti->offset = 0; 1060 spc_setsync(sc, ti); 1061 break; 1062 #endif 1063 #if SPC_USE_WIDE 1064 case SEND_WDTR: 1065 ti->flags &= ~DO_WIDE; 1066 ti->width = 0; 1067 break; 1068 #endif 1069 case SEND_INIT_DET_ERR: 1070 spc_sched_msgout(sc, SEND_ABORT); 1071 break; 1072 } 1073 break; 1074 1075 case MSG_NOOP: 1076 break; 1077 1078 case MSG_DISCONNECT: 1079 ti->dconns++; 1080 sc->sc_state = SPC_DISCONNECT; 1081 break; 1082 1083 case MSG_SAVEDATAPOINTER: 1084 acb->data_addr = sc->sc_dp; 1085 acb->data_length = sc->sc_dleft; 1086 break; 1087 1088 case MSG_RESTOREPOINTERS: 1089 sc->sc_dp = acb->data_addr; 1090 sc->sc_dleft = acb->data_length; 1091 sc->sc_cp = (u_char *)&acb->scsipi_cmd; 1092 sc->sc_cleft = acb->scsipi_cmd_length; 1093 break; 1094 1095 case MSG_EXTENDED: 1096 switch (sc->sc_imess[2]) { 1097 #if SPC_USE_SYNCHRONOUS 1098 case MSG_EXT_SDTR: 1099 if (sc->sc_imess[1] != 3) 1100 goto reject; 1101 ti->period = sc->sc_imess[3]; 1102 ti->offset = sc->sc_imess[4]; 1103 ti->flags &= ~DO_SYNC; 1104 if (ti->offset == 0) { 1105 } else if (ti->period < sc->sc_minsync || 1106 ti->period > sc->sc_maxsync || 1107 ti->offset > 8) { 1108 ti->period = ti->offset = 0; 1109 spc_sched_msgout(sc, SEND_SDTR); 1110 } else { 1111 scsipi_printaddr(acb->xs->xs_periph); 1112 printf("sync, offset %d, " 1113 "period %dnsec\n", 1114 ti->offset, ti->period * 4); 1115 } 1116 spc_setsync(sc, ti); 1117 break; 1118 #endif 1119 1120 #if SPC_USE_WIDE 1121 case MSG_EXT_WDTR: 1122 if (sc->sc_imess[1] != 2) 1123 goto reject; 1124 ti->width = sc->sc_imess[3]; 1125 ti->flags &= ~DO_WIDE; 1126 if (ti->width == 0) { 1127 } else if (ti->width > SPC_MAX_WIDTH) { 1128 ti->width = 0; 1129 spc_sched_msgout(sc, SEND_WDTR); 1130 } else { 1131 scsipi_printaddr(acb->xs->xs_periph); 1132 printf("wide, width %d\n", 1133 1 << (3 + ti->width)); 1134 } 1135 break; 1136 #endif 1137 1138 default: 1139 printf("%s: unrecognized MESSAGE EXTENDED; " 1140 "sending REJECT\n", sc->sc_dev.dv_xname); 1141 SPC_BREAK(); 1142 goto reject; 1143 } 1144 break; 1145 1146 default: 1147 printf("%s: unrecognized MESSAGE; sending REJECT\n", 1148 sc->sc_dev.dv_xname); 1149 SPC_BREAK(); 1150 reject: 1151 spc_sched_msgout(sc, SEND_REJECT); 1152 break; 1153 } 1154 break; 1155 1156 case SPC_RESELECTED: 1157 if (!MSG_ISIDENTIFY(sc->sc_imess[0])) { 1158 printf("%s: reselect without IDENTIFY; " 1159 "sending DEVICE RESET\n", sc->sc_dev.dv_xname); 1160 SPC_BREAK(); 1161 goto reset; 1162 } 1163 1164 (void) spc_reselect(sc, sc->sc_imess[0]); 1165 break; 1166 1167 default: 1168 printf("%s: unexpected MESSAGE IN; sending DEVICE RESET\n", 1169 sc->sc_dev.dv_xname); 1170 SPC_BREAK(); 1171 reset: 1172 spc_sched_msgout(sc, SEND_DEV_RESET); 1173 break; 1174 1175 #ifdef notdef 1176 abort: 1177 spc_sched_msgout(sc, SEND_ABORT); 1178 break; 1179 #endif 1180 } 1181 1182 #ifndef NO_MANUAL_XFER /* XXX */ 1183 /* Ack the last message byte. */ 1184 bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ACK); 1185 while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) != 0) 1186 continue; /* XXX needs timeout */ 1187 bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ACK); 1188 #endif 1189 1190 /* Go get the next message, if any. */ 1191 goto nextmsg; 1192 1193 out: 1194 #ifdef NO_MANUAL_XFER /* XXX */ 1195 /* Ack the last message byte. */ 1196 bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ACK); 1197 #endif 1198 SPC_MISC(("n=%d imess=0x%02x ", n, sc->sc_imess[0])); 1199 } 1200 1201 /* 1202 * Send the highest priority, scheduled message. 1203 */ 1204 void 1205 spc_msgout(sc) 1206 struct spc_softc *sc; 1207 { 1208 bus_space_tag_t iot = sc->sc_iot; 1209 bus_space_handle_t ioh = sc->sc_ioh; 1210 #if SPC_USE_SYNCHRONOUS 1211 struct spc_tinfo *ti; 1212 #endif 1213 int n; 1214 1215 SPC_TRACE(("spc_msgout ")); 1216 1217 if (sc->sc_prevphase == PH_MSGOUT) { 1218 if (sc->sc_omp == sc->sc_omess) { 1219 /* 1220 * This is a retransmission. 1221 * 1222 * We get here if the target stayed in MESSAGE OUT 1223 * phase. Section 5.1.9.2 of the SCSI 2 spec indicates 1224 * that all of the previously transmitted messages must 1225 * be sent again, in the same order. Therefore, we 1226 * requeue all the previously transmitted messages, and 1227 * start again from the top. Our simple priority 1228 * scheme keeps the messages in the right order. 1229 */ 1230 SPC_MISC(("retransmitting ")); 1231 sc->sc_msgpriq |= sc->sc_msgoutq; 1232 /* 1233 * Set ATN. If we're just sending a trivial 1-byte 1234 * message, we'll clear ATN later on anyway. 1235 */ 1236 bus_space_write_1(iot, ioh, SCMD, 1237 SCMD_SET_ATN); /* XXX? */ 1238 } else { 1239 /* This is a continuation of the previous message. */ 1240 n = sc->sc_omp - sc->sc_omess; 1241 goto nextbyte; 1242 } 1243 } 1244 1245 /* No messages transmitted so far. */ 1246 sc->sc_msgoutq = 0; 1247 sc->sc_lastmsg = 0; 1248 1249 nextmsg: 1250 /* Pick up highest priority message. */ 1251 sc->sc_currmsg = sc->sc_msgpriq & -sc->sc_msgpriq; 1252 sc->sc_msgpriq &= ~sc->sc_currmsg; 1253 sc->sc_msgoutq |= sc->sc_currmsg; 1254 1255 /* Build the outgoing message data. */ 1256 switch (sc->sc_currmsg) { 1257 case SEND_IDENTIFY: 1258 SPC_ASSERT(sc->sc_nexus != NULL); 1259 sc->sc_omess[0] = 1260 MSG_IDENTIFY(sc->sc_nexus->xs->xs_periph->periph_lun, 1); 1261 n = 1; 1262 break; 1263 1264 #if SPC_USE_SYNCHRONOUS 1265 case SEND_SDTR: 1266 SPC_ASSERT(sc->sc_nexus != NULL); 1267 ti = &sc->sc_tinfo[sc->sc_nexus->xs->xs_periph->periph_target]; 1268 sc->sc_omess[4] = MSG_EXTENDED; 1269 sc->sc_omess[3] = MSG_EXT_SDTR_LEN; 1270 sc->sc_omess[2] = MSG_EXT_SDTR; 1271 sc->sc_omess[1] = ti->period >> 2; 1272 sc->sc_omess[0] = ti->offset; 1273 n = 5; 1274 break; 1275 #endif 1276 1277 #if SPC_USE_WIDE 1278 case SEND_WDTR: 1279 SPC_ASSERT(sc->sc_nexus != NULL); 1280 ti = &sc->sc_tinfo[sc->sc_nexus->xs->xs_periph->periph_target]; 1281 sc->sc_omess[3] = MSG_EXTENDED; 1282 sc->sc_omess[2] = MSG_EXT_WDTR_LEN; 1283 sc->sc_omess[1] = MSG_EXT_WDTR; 1284 sc->sc_omess[0] = ti->width; 1285 n = 4; 1286 break; 1287 #endif 1288 1289 case SEND_DEV_RESET: 1290 sc->sc_flags |= SPC_ABORTING; 1291 sc->sc_omess[0] = MSG_BUS_DEV_RESET; 1292 n = 1; 1293 break; 1294 1295 case SEND_REJECT: 1296 sc->sc_omess[0] = MSG_MESSAGE_REJECT; 1297 n = 1; 1298 break; 1299 1300 case SEND_PARITY_ERROR: 1301 sc->sc_omess[0] = MSG_PARITY_ERROR; 1302 n = 1; 1303 break; 1304 1305 case SEND_INIT_DET_ERR: 1306 sc->sc_omess[0] = MSG_INITIATOR_DET_ERR; 1307 n = 1; 1308 break; 1309 1310 case SEND_ABORT: 1311 sc->sc_flags |= SPC_ABORTING; 1312 sc->sc_omess[0] = MSG_ABORT; 1313 n = 1; 1314 break; 1315 1316 default: 1317 printf("%s: unexpected MESSAGE OUT; sending NOOP\n", 1318 sc->sc_dev.dv_xname); 1319 SPC_BREAK(); 1320 sc->sc_omess[0] = MSG_NOOP; 1321 n = 1; 1322 break; 1323 } 1324 sc->sc_omp = &sc->sc_omess[n]; 1325 1326 nextbyte: 1327 /* Send message bytes. */ 1328 /* send TRANSFER command. */ 1329 bus_space_write_1(iot, ioh, TCH, n >> 16); 1330 bus_space_write_1(iot, ioh, TCM, n >> 8); 1331 bus_space_write_1(iot, ioh, TCL, n); 1332 bus_space_write_1(iot, ioh, PCTL, sc->sc_phase | PCTL_BFINT_ENAB); 1333 #ifdef NEED_DREQ_ON_HARDWARE_XFER 1334 bus_space_write_1(iot, ioh, SCMD, SCMD_XFR); /* XXX */ 1335 #else 1336 bus_space_write_1(iot, ioh, SCMD, 1337 SCMD_XFR | SCMD_PROG_XFR); 1338 #endif 1339 for (;;) { 1340 if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_BUSY) != 0) 1341 break; 1342 if (bus_space_read_1(iot, ioh, INTS) != 0) 1343 goto out; 1344 } 1345 for (;;) { 1346 #if 0 1347 for (;;) { 1348 if ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) != 0) 1349 break; 1350 /* Wait for REQINIT. XXX Need timeout. */ 1351 } 1352 #endif 1353 if (bus_space_read_1(iot, ioh, INTS) != 0) { 1354 /* 1355 * Target left MESSAGE OUT, possibly to reject 1356 * our message. 1357 * 1358 * If this is the last message being sent, then we 1359 * deassert ATN, since either the target is going to 1360 * ignore this message, or it's going to ask for a 1361 * retransmission via MESSAGE PARITY ERROR (in which 1362 * case we reassert ATN anyway). 1363 */ 1364 #if 0 1365 if (sc->sc_msgpriq == 0) 1366 bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ATN); 1367 #endif 1368 goto out; 1369 } 1370 1371 #if 0 1372 /* Clear ATN before last byte if this is the last message. */ 1373 if (n == 1 && sc->sc_msgpriq == 0) 1374 bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ATN); 1375 #endif 1376 1377 while ((bus_space_read_1(iot, ioh, SSTS) & SSTS_DREG_FULL) != 0) 1378 ; 1379 /* Send message byte. */ 1380 bus_space_write_1(iot, ioh, DREG, *--sc->sc_omp); 1381 --n; 1382 /* Keep track of the last message we've sent any bytes of. */ 1383 sc->sc_lastmsg = sc->sc_currmsg; 1384 #if 0 1385 /* Wait for ACK to be negated. XXX Need timeout. */ 1386 while ((bus_space_read_1(iot, ioh, PSNS) & ACKI) != 0) 1387 ; 1388 #endif 1389 1390 if (n == 0) 1391 break; 1392 } 1393 1394 /* We get here only if the entire message has been transmitted. */ 1395 if (sc->sc_msgpriq != 0) { 1396 /* There are more outgoing messages. */ 1397 goto nextmsg; 1398 } 1399 1400 /* 1401 * The last message has been transmitted. We need to remember the last 1402 * message transmitted (in case the target switches to MESSAGE IN phase 1403 * and sends a MESSAGE REJECT), and the list of messages transmitted 1404 * this time around (in case the target stays in MESSAGE OUT phase to 1405 * request a retransmit). 1406 */ 1407 1408 out: 1409 /* Disable REQ/ACK protocol. */ 1410 return; 1411 } 1412 1413 /* 1414 * spc_dataout_pio: perform a data transfer using the FIFO datapath in the spc 1415 * Precondition: The SCSI bus should be in the DOUT phase, with REQ asserted 1416 * and ACK deasserted (i.e. waiting for a data byte) 1417 * 1418 * This new revision has been optimized (I tried) to make the common case fast, 1419 * and the rarer cases (as a result) somewhat more comlex 1420 */ 1421 int 1422 spc_dataout_pio(sc, p, n) 1423 struct spc_softc *sc; 1424 u_char *p; 1425 int n; 1426 { 1427 bus_space_tag_t iot = sc->sc_iot; 1428 bus_space_handle_t ioh = sc->sc_ioh; 1429 u_char intstat = 0; 1430 int out = 0; 1431 #define DOUTAMOUNT 8 /* Full FIFO */ 1432 1433 SPC_TRACE(("spc_dataout_pio ")); 1434 /* send TRANSFER command. */ 1435 bus_space_write_1(iot, ioh, TCH, n >> 16); 1436 bus_space_write_1(iot, ioh, TCM, n >> 8); 1437 bus_space_write_1(iot, ioh, TCL, n); 1438 bus_space_write_1(iot, ioh, PCTL, sc->sc_phase | PCTL_BFINT_ENAB); 1439 #ifdef NEED_DREQ_ON_HARDWARE_XFER 1440 bus_space_write_1(iot, ioh, SCMD, SCMD_XFR); /* XXX */ 1441 #else 1442 bus_space_write_1(iot, ioh, SCMD, 1443 SCMD_XFR | SCMD_PROG_XFR); /* XXX */ 1444 #endif 1445 for (;;) { 1446 if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_BUSY) != 0) 1447 break; 1448 if (bus_space_read_1(iot, ioh, INTS) != 0) 1449 break; 1450 } 1451 1452 /* 1453 * I have tried to make the main loop as tight as possible. This 1454 * means that some of the code following the loop is a bit more 1455 * complex than otherwise. 1456 */ 1457 while (n > 0) { 1458 int xfer; 1459 1460 for (;;) { 1461 intstat = bus_space_read_1(iot, ioh, INTS); 1462 /* Wait till buffer is empty. */ 1463 if ((bus_space_read_1(iot, ioh, SSTS) & 1464 SSTS_DREG_EMPTY) != 0) 1465 break; 1466 /* Break on interrupt. */ 1467 if (intstat != 0) 1468 goto phasechange; 1469 } 1470 1471 xfer = min(DOUTAMOUNT, n); 1472 1473 SPC_MISC(("%d> ", xfer)); 1474 1475 n -= xfer; 1476 out += xfer; 1477 1478 bus_space_write_multi_1(iot, ioh, DREG, p, xfer); 1479 p += xfer; 1480 } 1481 1482 if (out == 0) { 1483 for (;;) { 1484 if (bus_space_read_1(iot, ioh, INTS) != 0) 1485 break; 1486 } 1487 SPC_MISC(("extra data ")); 1488 } else { 1489 /* See the bytes off chip */ 1490 for (;;) { 1491 /* Wait till buffer is empty. */ 1492 if ((bus_space_read_1(iot, ioh, SSTS) & 1493 SSTS_DREG_EMPTY) != 0) 1494 break; 1495 intstat = bus_space_read_1(iot, ioh, INTS); 1496 /* Break on interrupt. */ 1497 if (intstat != 0) 1498 goto phasechange; 1499 } 1500 } 1501 1502 phasechange: 1503 /* Stop the FIFO data path. */ 1504 1505 if (intstat != 0) { 1506 /* Some sort of phase change. */ 1507 int amount; 1508 1509 amount = (bus_space_read_1(iot, ioh, TCH) << 16) | 1510 (bus_space_read_1(iot, ioh, TCM) << 8) | 1511 bus_space_read_1(iot, ioh, TCL); 1512 if (amount > 0) { 1513 out -= amount; 1514 SPC_MISC(("+%d ", amount)); 1515 } 1516 } 1517 1518 return out; 1519 } 1520 1521 /* 1522 * spc_datain_pio: perform data transfers using the FIFO datapath in the spc 1523 * Precondition: The SCSI bus should be in the DIN phase, with REQ asserted 1524 * and ACK deasserted (i.e. at least one byte is ready). 1525 * 1526 * For now, uses a pretty dumb algorithm, hangs around until all data has been 1527 * transferred. This, is OK for fast targets, but not so smart for slow 1528 * targets which don't disconnect or for huge transfers. 1529 */ 1530 int 1531 spc_datain_pio(sc, p, n) 1532 struct spc_softc *sc; 1533 u_char *p; 1534 int n; 1535 { 1536 bus_space_tag_t iot = sc->sc_iot; 1537 bus_space_handle_t ioh = sc->sc_ioh; 1538 int in = 0; 1539 u_int8_t intstat, sstat; 1540 #define DINAMOUNT 8 /* Full FIFO */ 1541 1542 SPC_TRACE(("spc_datain_pio ")); 1543 /* send TRANSFER command. */ 1544 bus_space_write_1(iot, ioh, TCH, n >> 16); 1545 bus_space_write_1(iot, ioh, TCM, n >> 8); 1546 bus_space_write_1(iot, ioh, TCL, n); 1547 bus_space_write_1(iot, ioh, PCTL, sc->sc_phase | PCTL_BFINT_ENAB); 1548 #ifdef NEED_DREQ_ON_HARDWARE_XFER 1549 bus_space_write_1(iot, ioh, SCMD, SCMD_XFR); /* XXX */ 1550 #else 1551 bus_space_write_1(iot, ioh, SCMD, 1552 SCMD_XFR | SCMD_PROG_XFR); /* XXX */ 1553 #endif 1554 for (;;) { 1555 if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_BUSY) != 0) 1556 break; 1557 if (bus_space_read_1(iot, ioh, INTS) != 0) 1558 goto phasechange; 1559 } 1560 1561 /* 1562 * We leave this loop if one or more of the following is true: 1563 * a) phase != PH_DATAIN && FIFOs are empty 1564 * b) reset has occurred or busfree is detected. 1565 */ 1566 while (n > 0) { 1567 int xfer; 1568 1569 /* Wait for fifo half full or phase mismatch */ 1570 for (;;) { 1571 /* XXX needs timeout */ 1572 intstat = bus_space_read_1(iot, ioh, INTS); 1573 sstat = bus_space_read_1(iot, ioh, SSTS); 1574 if (intstat != 0 || 1575 (sstat & SSTS_DREG_EMPTY) == 0) 1576 break; 1577 } 1578 1579 #ifdef NEED_DREQ_ON_HARDWARE_XFER 1580 if (intstat != 0) 1581 goto phasechange; 1582 #endif 1583 1584 if (sstat & SSTS_DREG_FULL) { 1585 xfer = DINAMOUNT; 1586 n -= xfer; 1587 in += xfer; 1588 bus_space_read_multi_1(iot, ioh, DREG, p, xfer); 1589 p += xfer; 1590 } 1591 while (n > 0 && 1592 (bus_space_read_1(iot, ioh, SSTS) & SSTS_DREG_EMPTY) == 0) { 1593 n--; 1594 in++; 1595 *p++ = bus_space_read_1(iot, ioh, DREG); 1596 } 1597 1598 if (intstat != 0) 1599 goto phasechange; 1600 } 1601 1602 /* 1603 * Some SCSI-devices are rude enough to transfer more data than what 1604 * was requested, e.g. 2048 bytes from a CD-ROM instead of the 1605 * requested 512. Test for progress, i.e. real transfers. If no real 1606 * transfers have been performed (n is probably already zero) and the 1607 * FIFO is not empty, waste some bytes.... 1608 */ 1609 if (in == 0) { 1610 for (;;) { 1611 /* XXX needs timeout */ 1612 if (bus_space_read_1(iot, ioh, INTS) != 0) 1613 break; 1614 } 1615 SPC_MISC(("extra data ")); 1616 } 1617 1618 phasechange: 1619 /* Stop the FIFO data path. */ 1620 1621 return in; 1622 } 1623 1624 /* 1625 * Catch an interrupt from the adaptor 1626 */ 1627 /* 1628 * This is the workhorse routine of the driver. 1629 * Deficiencies (for now): 1630 * 1) always uses programmed I/O 1631 */ 1632 int 1633 spc_intr(arg) 1634 void *arg; 1635 { 1636 struct spc_softc *sc = arg; 1637 bus_space_tag_t iot = sc->sc_iot; 1638 bus_space_handle_t ioh = sc->sc_ioh; 1639 u_char ints; 1640 struct spc_acb *acb; 1641 struct scsipi_periph *periph; 1642 struct spc_tinfo *ti; 1643 int n; 1644 1645 /* 1646 * Disable interrupt. 1647 */ 1648 bus_space_write_1(iot, ioh, SCTL, 1649 bus_space_read_1(iot, ioh, SCTL) & ~SCTL_INTR_ENAB); 1650 1651 SPC_TRACE(("spc_intr ")); 1652 1653 ints = bus_space_read_1(iot, ioh, INTS); 1654 if (ints == 0) 1655 goto out; 1656 1657 if (sc->sc_dma_done != NULL && 1658 sc->sc_state == SPC_CONNECTED && 1659 (sc->sc_flags & SPC_DOINGDMA) != 0 && 1660 (sc->sc_phase == PH_DATAOUT || sc->sc_phase == PH_DATAIN)) { 1661 (*sc->sc_dma_done)(sc); 1662 } 1663 1664 loop: 1665 /* 1666 * Loop until transfer completion. 1667 */ 1668 /* 1669 * First check for abnormal conditions, such as reset. 1670 */ 1671 ints = bus_space_read_1(iot, ioh, INTS); 1672 SPC_MISC(("ints = 0x%x ", ints)); 1673 1674 if ((ints & INTS_RST) != 0) { 1675 printf("%s: SCSI bus reset\n", sc->sc_dev.dv_xname); 1676 goto reset; 1677 } 1678 1679 /* 1680 * Check for less serious errors. 1681 */ 1682 if ((bus_space_read_1(iot, ioh, SERR) & (SERR_SCSI_PAR|SERR_SPC_PAR)) 1683 != 0) { 1684 printf("%s: SCSI bus parity error\n", sc->sc_dev.dv_xname); 1685 if (sc->sc_prevphase == PH_MSGIN) { 1686 sc->sc_flags |= SPC_DROP_MSGIN; 1687 spc_sched_msgout(sc, SEND_PARITY_ERROR); 1688 } else 1689 spc_sched_msgout(sc, SEND_INIT_DET_ERR); 1690 } 1691 1692 /* 1693 * If we're not already busy doing something test for the following 1694 * conditions: 1695 * 1) We have been reselected by something 1696 * 2) We have selected something successfully 1697 * 3) Our selection process has timed out 1698 * 4) This is really a bus free interrupt just to get a new command 1699 * going? 1700 * 5) Spurious interrupt? 1701 */ 1702 switch (sc->sc_state) { 1703 case SPC_IDLE: 1704 case SPC_SELECTING: 1705 SPC_MISC(("ints:0x%02x ", ints)); 1706 1707 if ((ints & INTS_SEL) != 0) { 1708 /* 1709 * We don't currently support target mode. 1710 */ 1711 printf("%s: target mode selected; going to BUS FREE\n", 1712 sc->sc_dev.dv_xname); 1713 1714 goto sched; 1715 } else if ((ints & INTS_RESEL) != 0) { 1716 SPC_MISC(("reselected ")); 1717 1718 /* 1719 * If we're trying to select a target ourselves, 1720 * push our command back into the ready list. 1721 */ 1722 if (sc->sc_state == SPC_SELECTING) { 1723 SPC_MISC(("backoff selector ")); 1724 SPC_ASSERT(sc->sc_nexus != NULL); 1725 acb = sc->sc_nexus; 1726 sc->sc_nexus = NULL; 1727 TAILQ_INSERT_HEAD(&sc->ready_list, acb, chain); 1728 } 1729 1730 /* Save reselection ID. */ 1731 sc->sc_selid = bus_space_read_1(iot, ioh, TEMP); 1732 1733 sc->sc_state = SPC_RESELECTED; 1734 } else if ((ints & INTS_CMD_DONE) != 0) { 1735 SPC_MISC(("selected ")); 1736 1737 /* 1738 * We have selected a target. Things to do: 1739 * a) Determine what message(s) to send. 1740 * b) Verify that we're still selecting the target. 1741 * c) Mark device as busy. 1742 */ 1743 if (sc->sc_state != SPC_SELECTING) { 1744 printf("%s: selection out while idle; " 1745 "resetting\n", sc->sc_dev.dv_xname); 1746 SPC_BREAK(); 1747 goto reset; 1748 } 1749 SPC_ASSERT(sc->sc_nexus != NULL); 1750 acb = sc->sc_nexus; 1751 periph = acb->xs->xs_periph; 1752 ti = &sc->sc_tinfo[periph->periph_target]; 1753 1754 sc->sc_msgpriq = SEND_IDENTIFY; 1755 if (acb->flags & ACB_RESET) 1756 sc->sc_msgpriq |= SEND_DEV_RESET; 1757 else if (acb->flags & ACB_ABORT) 1758 sc->sc_msgpriq |= SEND_ABORT; 1759 else { 1760 #if SPC_USE_SYNCHRONOUS 1761 if ((ti->flags & DO_SYNC) != 0) 1762 sc->sc_msgpriq |= SEND_SDTR; 1763 #endif 1764 #if SPC_USE_WIDE 1765 if ((ti->flags & DO_WIDE) != 0) 1766 sc->sc_msgpriq |= SEND_WDTR; 1767 #endif 1768 } 1769 1770 acb->flags |= ACB_NEXUS; 1771 ti->lubusy |= (1 << periph->periph_lun); 1772 1773 /* Do an implicit RESTORE POINTERS. */ 1774 sc->sc_dp = acb->data_addr; 1775 sc->sc_dleft = acb->data_length; 1776 sc->sc_cp = (u_char *)&acb->scsipi_cmd; 1777 sc->sc_cleft = acb->scsipi_cmd_length; 1778 1779 /* On our first connection, schedule a timeout. */ 1780 if ((acb->xs->xs_control & XS_CTL_POLL) == 0) 1781 callout_reset(&acb->xs->xs_callout, 1782 mstohz(acb->timeout), spc_timeout, acb); 1783 1784 sc->sc_state = SPC_CONNECTED; 1785 } else if ((ints & INTS_TIMEOUT) != 0) { 1786 SPC_MISC(("selection timeout ")); 1787 1788 if (sc->sc_state != SPC_SELECTING) { 1789 printf("%s: selection timeout while idle; " 1790 "resetting\n", sc->sc_dev.dv_xname); 1791 SPC_BREAK(); 1792 goto reset; 1793 } 1794 SPC_ASSERT(sc->sc_nexus != NULL); 1795 acb = sc->sc_nexus; 1796 1797 delay(250); 1798 1799 acb->xs->error = XS_SELTIMEOUT; 1800 goto finish; 1801 } else { 1802 if (sc->sc_state != SPC_IDLE) { 1803 printf("%s: BUS FREE while not idle; " 1804 "state=%d\n", 1805 sc->sc_dev.dv_xname, sc->sc_state); 1806 SPC_BREAK(); 1807 goto out; 1808 } 1809 1810 goto sched; 1811 } 1812 1813 /* 1814 * Turn off selection stuff, and prepare to catch bus free 1815 * interrupts, parity errors, and phase changes. 1816 */ 1817 1818 sc->sc_flags = 0; 1819 sc->sc_prevphase = PH_INVALID; 1820 goto dophase; 1821 } 1822 1823 if ((ints & INTS_DISCON) != 0) { 1824 /* We've gone to BUS FREE phase. */ 1825 /* disable disconnect interrupt */ 1826 bus_space_write_1(iot, ioh, PCTL, 1827 bus_space_read_1(iot, ioh, PCTL) & ~PCTL_BFINT_ENAB); 1828 /* XXX reset interrput */ 1829 bus_space_write_1(iot, ioh, INTS, ints); 1830 1831 switch (sc->sc_state) { 1832 case SPC_RESELECTED: 1833 goto sched; 1834 1835 case SPC_CONNECTED: 1836 SPC_ASSERT(sc->sc_nexus != NULL); 1837 acb = sc->sc_nexus; 1838 1839 #if SPC_USE_SYNCHRONOUS + SPC_USE_WIDE 1840 if (sc->sc_prevphase == PH_MSGOUT) { 1841 /* 1842 * If the target went to BUS FREE phase during 1843 * or immediately after sending a SDTR or WDTR 1844 * message, disable negotiation. 1845 */ 1846 periph = acb->xs->xs_periph; 1847 ti = &sc->sc_tinfo[periph->periph_target]; 1848 switch (sc->sc_lastmsg) { 1849 #if SPC_USE_SYNCHRONOUS 1850 case SEND_SDTR: 1851 ti->flags &= ~DO_SYNC; 1852 ti->period = ti->offset = 0; 1853 break; 1854 #endif 1855 #if SPC_USE_WIDE 1856 case SEND_WDTR: 1857 ti->flags &= ~DO_WIDE; 1858 ti->width = 0; 1859 break; 1860 #endif 1861 } 1862 } 1863 #endif 1864 1865 if ((sc->sc_flags & SPC_ABORTING) == 0) { 1866 /* 1867 * Section 5.1.1 of the SCSI 2 spec suggests 1868 * issuing a REQUEST SENSE following an 1869 * unexpected disconnect. Some devices go into 1870 * a contingent allegiance condition when 1871 * disconnecting, and this is necessary to 1872 * clean up their state. 1873 */ 1874 printf("%s: unexpected disconnect; " 1875 "sending REQUEST SENSE\n", 1876 sc->sc_dev.dv_xname); 1877 SPC_BREAK(); 1878 acb->target_stat = SCSI_CHECK; 1879 acb->xs->error = XS_NOERROR; 1880 goto finish; 1881 } 1882 1883 acb->xs->error = XS_DRIVER_STUFFUP; 1884 goto finish; 1885 1886 case SPC_DISCONNECT: 1887 SPC_ASSERT(sc->sc_nexus != NULL); 1888 acb = sc->sc_nexus; 1889 TAILQ_INSERT_HEAD(&sc->nexus_list, acb, chain); 1890 sc->sc_nexus = NULL; 1891 goto sched; 1892 1893 case SPC_CMDCOMPLETE: 1894 SPC_ASSERT(sc->sc_nexus != NULL); 1895 acb = sc->sc_nexus; 1896 goto finish; 1897 } 1898 } 1899 else if ((ints & INTS_CMD_DONE) != 0 && 1900 sc->sc_prevphase == PH_MSGIN && 1901 sc->sc_state != SPC_CONNECTED) 1902 goto out; 1903 1904 dophase: 1905 #if 0 1906 if ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) == 0) { 1907 /* Wait for REQINIT. */ 1908 goto out; 1909 } 1910 #else 1911 bus_space_write_1(iot, ioh, INTS, ints); 1912 ints = 0; 1913 while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) == 0) 1914 delay(1); /* need timeout XXX */ 1915 #endif 1916 1917 /* 1918 * State transition. 1919 */ 1920 sc->sc_phase = bus_space_read_1(iot, ioh, PSNS) & PH_MASK; 1921 #if 0 1922 bus_space_write_1(iot, ioh, PCTL, sc->sc_phase); 1923 #endif 1924 1925 SPC_MISC(("phase=%d\n", sc->sc_phase)); 1926 switch (sc->sc_phase) { 1927 case PH_MSGOUT: 1928 if (sc->sc_state != SPC_CONNECTED && 1929 sc->sc_state != SPC_RESELECTED) 1930 break; 1931 spc_msgout(sc); 1932 sc->sc_prevphase = PH_MSGOUT; 1933 goto loop; 1934 1935 case PH_MSGIN: 1936 if (sc->sc_state != SPC_CONNECTED && 1937 sc->sc_state != SPC_RESELECTED) 1938 break; 1939 spc_msgin(sc); 1940 sc->sc_prevphase = PH_MSGIN; 1941 goto loop; 1942 1943 case PH_CMD: 1944 if (sc->sc_state != SPC_CONNECTED) 1945 break; 1946 #if SPC_DEBUG 1947 if ((spc_debug & SPC_SHOWMISC) != 0) { 1948 SPC_ASSERT(sc->sc_nexus != NULL); 1949 acb = sc->sc_nexus; 1950 printf("cmd=0x%02x+%d ", 1951 acb->scsipi_cmd.opcode, acb->scsipi_cmd_length - 1); 1952 } 1953 #endif 1954 n = spc_dataout_pio(sc, sc->sc_cp, sc->sc_cleft); 1955 sc->sc_cp += n; 1956 sc->sc_cleft -= n; 1957 sc->sc_prevphase = PH_CMD; 1958 goto loop; 1959 1960 case PH_DATAOUT: 1961 if (sc->sc_state != SPC_CONNECTED) 1962 break; 1963 SPC_MISC(("dataout dleft=%d ", sc->sc_dleft)); 1964 if (sc->sc_dma_start != NULL && 1965 sc->sc_dleft > SPC_MIN_DMA_LEN) { 1966 (*sc->sc_dma_start)(sc, sc->sc_dp, sc->sc_dleft, 0); 1967 sc->sc_prevphase = PH_DATAOUT; 1968 goto out; 1969 } 1970 n = spc_dataout_pio(sc, sc->sc_dp, sc->sc_dleft); 1971 sc->sc_dp += n; 1972 sc->sc_dleft -= n; 1973 sc->sc_prevphase = PH_DATAOUT; 1974 goto loop; 1975 1976 case PH_DATAIN: 1977 if (sc->sc_state != SPC_CONNECTED) 1978 break; 1979 SPC_MISC(("datain ")); 1980 if (sc->sc_dma_start != NULL && 1981 sc->sc_dleft > SPC_MIN_DMA_LEN) { 1982 (*sc->sc_dma_start)(sc, sc->sc_dp, sc->sc_dleft, 1); 1983 sc->sc_prevphase = PH_DATAIN; 1984 goto out; 1985 } 1986 n = spc_datain_pio(sc, sc->sc_dp, sc->sc_dleft); 1987 sc->sc_dp += n; 1988 sc->sc_dleft -= n; 1989 sc->sc_prevphase = PH_DATAIN; 1990 goto loop; 1991 1992 case PH_STAT: 1993 if (sc->sc_state != SPC_CONNECTED) 1994 break; 1995 SPC_ASSERT(sc->sc_nexus != NULL); 1996 acb = sc->sc_nexus; 1997 1998 #ifdef NO_MANUAL_XFER 1999 spc_datain_pio(sc, &acb->target_stat, 1); 2000 #else 2001 if ((bus_space_read_1(iot, ioh, PSNS) & PSNS_ATN) != 0) 2002 bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ATN); 2003 while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) == 0) 2004 continue; /* XXX needs timeout */ 2005 bus_space_write_1(iot, ioh, PCTL, PH_STAT); 2006 acb->target_stat = bus_space_read_1(iot, ioh, TEMP); 2007 bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ACK); 2008 while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) != 0) 2009 continue; /* XXX needs timeout */ 2010 bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ACK); 2011 #endif 2012 2013 SPC_MISC(("target_stat=0x%02x ", acb->target_stat)); 2014 sc->sc_prevphase = PH_STAT; 2015 goto loop; 2016 } 2017 2018 printf("%s: unexpected bus phase; resetting\n", sc->sc_dev.dv_xname); 2019 SPC_BREAK(); 2020 reset: 2021 spc_init(sc); 2022 return 1; 2023 2024 finish: 2025 callout_stop(&acb->xs->xs_callout); 2026 bus_space_write_1(iot, ioh, INTS, ints); 2027 ints = 0; 2028 spc_done(sc, acb); 2029 goto out; 2030 2031 sched: 2032 sc->sc_state = SPC_IDLE; 2033 spc_sched(sc); 2034 goto out; 2035 2036 out: 2037 if (ints) 2038 bus_space_write_1(iot, ioh, INTS, ints); 2039 bus_space_write_1(iot, ioh, SCTL, 2040 bus_space_read_1(iot, ioh, SCTL) | SCTL_INTR_ENAB); 2041 return 1; 2042 } 2043 2044 void 2045 spc_abort(sc, acb) 2046 struct spc_softc *sc; 2047 struct spc_acb *acb; 2048 { 2049 2050 /* 2 secs for the abort */ 2051 acb->timeout = SPC_ABORT_TIMEOUT; 2052 acb->flags |= ACB_ABORT; 2053 2054 if (acb == sc->sc_nexus) { 2055 /* 2056 * If we're still selecting, the message will be scheduled 2057 * after selection is complete. 2058 */ 2059 if (sc->sc_state == SPC_CONNECTED) 2060 spc_sched_msgout(sc, SEND_ABORT); 2061 } else { 2062 spc_dequeue(sc, acb); 2063 TAILQ_INSERT_HEAD(&sc->ready_list, acb, chain); 2064 if (sc->sc_state == SPC_IDLE) 2065 spc_sched(sc); 2066 } 2067 } 2068 2069 void 2070 spc_timeout(arg) 2071 void *arg; 2072 { 2073 struct spc_acb *acb = arg; 2074 struct scsipi_xfer *xs = acb->xs; 2075 struct scsipi_periph *periph = xs->xs_periph; 2076 struct spc_softc *sc; 2077 int s; 2078 2079 sc = (void *)periph->periph_channel->chan_adapter->adapt_dev; 2080 scsipi_printaddr(periph); 2081 printf("timed out"); 2082 2083 s = splbio(); 2084 2085 if (acb->flags & ACB_ABORT) { 2086 /* abort timed out */ 2087 printf(" AGAIN\n"); 2088 /* XXX Must reset! */ 2089 } else { 2090 /* abort the operation that has timed out */ 2091 printf("\n"); 2092 acb->xs->error = XS_TIMEOUT; 2093 spc_abort(sc, acb); 2094 } 2095 2096 splx(s); 2097 } 2098 2099 #ifdef SPC_DEBUG 2100 /* 2101 * The following functions are mostly used for debugging purposes, either 2102 * directly called from the driver or from the kernel debugger. 2103 */ 2104 2105 void 2106 spc_show_scsi_cmd(acb) 2107 struct spc_acb *acb; 2108 { 2109 u_char *b = (u_char *)&acb->scsipi_cmd; 2110 int i; 2111 2112 scsipi_printaddr(acb->xs->xs_periph); 2113 if ((acb->xs->xs_control & XS_CTL_RESET) == 0) { 2114 for (i = 0; i < acb->scsipi_cmd_length; i++) { 2115 if (i) 2116 printf(","); 2117 printf("%x", b[i]); 2118 } 2119 printf("\n"); 2120 } else 2121 printf("RESET\n"); 2122 } 2123 2124 void 2125 spc_print_acb(acb) 2126 struct spc_acb *acb; 2127 { 2128 2129 printf("acb@%p xs=%p flags=%x", acb, acb->xs, acb->flags); 2130 printf(" dp=%p dleft=%d target_stat=%x\n", 2131 acb->data_addr, acb->data_length, acb->target_stat); 2132 spc_show_scsi_cmd(acb); 2133 } 2134 2135 void 2136 spc_print_active_acb() 2137 { 2138 struct spc_acb *acb; 2139 struct spc_softc *sc = spc_cd.cd_devs[0]; /* XXX */ 2140 2141 printf("ready list:\n"); 2142 TAILQ_FOREACH(acb, &sc->ready_list, chain) 2143 spc_print_acb(acb); 2144 printf("nexus:\n"); 2145 if (sc->sc_nexus != NULL) 2146 spc_print_acb(sc->sc_nexus); 2147 printf("nexus list:\n"); 2148 TAILQ_FOREACH(acb, &sc->nexus_list, chain) 2149 spc_print_acb(acb); 2150 } 2151 2152 void 2153 spc_dump89352(sc) 2154 struct spc_softc *sc; 2155 { 2156 bus_space_tag_t iot = sc->sc_iot; 2157 bus_space_handle_t ioh = sc->sc_ioh; 2158 2159 printf("mb89352: BDID=%x SCTL=%x SCMD=%x TMOD=%x\n", 2160 bus_space_read_1(iot, ioh, BDID), 2161 bus_space_read_1(iot, ioh, SCTL), 2162 bus_space_read_1(iot, ioh, SCMD), 2163 bus_space_read_1(iot, ioh, TMOD)); 2164 printf(" INTS=%x PSNS=%x SSTS=%x SERR=%x PCTL=%x\n", 2165 bus_space_read_1(iot, ioh, INTS), 2166 bus_space_read_1(iot, ioh, PSNS), 2167 bus_space_read_1(iot, ioh, SSTS), 2168 bus_space_read_1(iot, ioh, SERR), 2169 bus_space_read_1(iot, ioh, PCTL)); 2170 printf(" MBC=%x DREG=%x TEMP=%x TCH=%x TCM=%x\n", 2171 bus_space_read_1(iot, ioh, MBC), 2172 #if 0 2173 bus_space_read_1(iot, ioh, DREG), 2174 #else 2175 0, 2176 #endif 2177 bus_space_read_1(iot, ioh, TEMP), 2178 bus_space_read_1(iot, ioh, TCH), 2179 bus_space_read_1(iot, ioh, TCM)); 2180 printf(" TCL=%x EXBF=%x\n", 2181 bus_space_read_1(iot, ioh, TCL), 2182 bus_space_read_1(iot, ioh, EXBF)); 2183 } 2184 2185 void 2186 spc_dump_driver(sc) 2187 struct spc_softc *sc; 2188 { 2189 struct spc_tinfo *ti; 2190 int i; 2191 2192 printf("nexus=%p prevphase=%x\n", sc->sc_nexus, sc->sc_prevphase); 2193 printf("state=%x msgin=%x msgpriq=%x msgoutq=%x lastmsg=%x " 2194 "currmsg=%x\n", sc->sc_state, sc->sc_imess[0], 2195 sc->sc_msgpriq, sc->sc_msgoutq, sc->sc_lastmsg, sc->sc_currmsg); 2196 for (i = 0; i < 7; i++) { 2197 ti = &sc->sc_tinfo[i]; 2198 printf("tinfo%d: %d cmds %d disconnects %d timeouts", 2199 i, ti->cmds, ti->dconns, ti->touts); 2200 printf(" %d senses flags=%x\n", ti->senses, ti->flags); 2201 } 2202 } 2203 #endif 2204
Indexes created Wed Sep 24 22:09:59 GMT 2025