1/* $NetBSD$ */ 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) 1995 Scott Stevens 39 * Copyright (c) 1995 Daniel Widenfalk 40 * Copyright (c) 1994 Christian E. Hopps 41 * 42 * This code is derived from software contributed to Berkeley by 43 * Van Jacobson of Lawrence Berkeley Laboratory. 44 * 45 * Redistribution and use in source and binary forms, with or without 46 * modification, are permitted provided that the following conditions 47 * are met: 48 * 1. Redistributions of source code must retain the above copyright 49 * notice, this list of conditions and the following disclaimer. 50 * 2. Redistributions in binary form must reproduce the above copyright 51 * notice, this list of conditions and the following disclaimer in the 52 * documentation and/or other materials provided with the distribution. 53 * 3. All advertising materials mentioning features or use of this software 54 * must display the following acknowledgement: 55 * This product includes software developed by the University of 56 * California, Berkeley and its contributors. 57 * 4. Neither the name of the University nor the names of its contributors 58 * may be used to endorse or promote products derived from this software 59 * without specific prior written permission. 60 * 61 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 62 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 63 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 64 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 65 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 66 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 67 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 68 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 69 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 70 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 71 * SUCH DAMAGE. 72 * 73 * @(#)scsi.c 7.5 (Berkeley) 5/4/91 74 */ 75 76/* 77 * AMD AM53CF94 scsi adaptor driver 78 * 79 * Functionally compatible with the FAS216 80 * 81 * Apart from a very small patch to set up control register 4 82 */ 83 84/* 85 * Modified for NetBSD/arm32 by Scott Stevens 86 */ 87 88#include <sys/cdefs.h> 89__KERNEL_RCSID(0, "$NetBSD$"); 90 91#include <sys/param.h> 92#include <sys/systm.h> 93#include <sys/device.h> 94#include <sys/buf.h> 95#include <sys/proc.h> 96#include <dev/scsipi/scsi_all.h> 97#include <dev/scsipi/scsipi_all.h> 98#include <dev/scsipi/scsiconf.h> 99 100#include <uvm/uvm_extern.h> 101 102#include <machine/pmap.h> 103#include <machine/cpu.h> 104#include <machine/io.h> 105#include <machine/intr.h> 106#include <arm/arm32/katelib.h> 107#include <acorn32/podulebus/podulebus.h> 108#include <acorn32/podulebus/escreg.h> 109#include <acorn32/podulebus/escvar.h> 110 111void escinitialize(struct esc_softc *); 112void esc_minphys(struct buf *bp); 113void esc_scsi_request(struct scsipi_channel *, 114 scsipi_adapter_req_t, void *); 115void esc_donextcmd(struct esc_softc *dev, struct esc_pending *pendp); 116void esc_scsidone(struct esc_softc *dev, struct scsipi_xfer *xs, 117 int stat); 118void escintr(struct esc_softc *dev); 119void esciwait(struct esc_softc *dev); 120void escreset(struct esc_softc *dev, int how); 121int escselect(struct esc_softc *dev, struct esc_pending *pendp, 122 unsigned char *cbuf, int clen, 123 unsigned char *buf, int len, int mode); 124void escicmd(struct esc_softc *dev, struct esc_pending *pendp); 125int escgo(struct esc_softc *dev, struct esc_pending *pendp); 126 127void esc_init_nexus(struct esc_softc *, struct nexus *); 128void esc_save_pointers(struct esc_softc *); 129void esc_restore_pointers(struct esc_softc *); 130void esc_ixfer(struct esc_softc *); 131void esc_build_sdtrm(struct esc_softc *, int, int); 132int esc_select_unit(struct esc_softc *, short); 133struct nexus *esc_arbitate_target(struct esc_softc *, int); 134void esc_setup_nexus(struct esc_softc *, struct nexus *, struct esc_pending *, 135 unsigned char *, int, unsigned char *, int, int); 136int esc_pretests(struct esc_softc *, esc_regmap_p); 137int esc_midaction(struct esc_softc *, esc_regmap_p, struct nexus *); 138int esc_postaction(struct esc_softc *, esc_regmap_p, struct nexus *); 139 140 141/* 142 * Initialize these to make 'em patchable. Defaults to enable sync and discon. 143 */ 144u_char esc_inhibit_sync[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; 145u_char esc_inhibit_disc[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; 146 147#undef DEBUG 148#define DEBUG 149#ifdef DEBUG 150#define QPRINTF(a) if (esc_debug > 1) printf a 151int esc_debug = 2; 152#else 153#define QPRINTF 154#endif 155 156/* 157 * default minphys routine for esc based controllers 158 */ 159void 160esc_minphys(struct buf *bp) 161{ 162 163 /* 164 * No max transfer at this level. 165 */ 166 minphys(bp); 167} 168 169/* 170 * Initialize the nexus structs. 171 */ 172void 173esc_init_nexus(struct esc_softc *dev, struct nexus *nexus) 174{ 175 memset(nexus, 0, sizeof(struct nexus)); 176 177 nexus->state = ESC_NS_IDLE; 178 nexus->period = 200; 179 nexus->offset = 0; 180 nexus->syncper = 5; 181 nexus->syncoff = 0; 182 nexus->config3 = dev->sc_config3 & ~ESC_CFG3_FASTSCSI; 183} 184 185void 186escinitialize(struct esc_softc *dev) 187{ 188 u_int *pte; 189 int i; 190 191 dev->sc_led_status = 0; 192 193 TAILQ_INIT(&dev->sc_xs_pending); 194 TAILQ_INIT(&dev->sc_xs_free); 195 196/* 197 * Initialize the esc_pending structs and link them into the free list. We 198 * have to set vm_link_data.pages to 0 or the vm FIX won't work. 199 */ 200 for(i=0; i<MAXPENDING; i++) { 201 TAILQ_INSERT_TAIL(&dev->sc_xs_free, &dev->sc_xs_store[i], 202 link); 203 } 204 205/* 206 * Calculate the correct clock conversion factor 2 <= factor <= 8, i.e. set 207 * the factor to clock_freq / 5 (int). 208 */ 209 if (dev->sc_clock_freq <= 10) 210 dev->sc_clock_conv_fact = 2; 211 if (dev->sc_clock_freq <= 40) 212 dev->sc_clock_conv_fact = 2+((dev->sc_clock_freq-10)/5); 213 else 214 panic("escinitialize: Clock frequence too high"); 215 216/* Setup and save the basic configuration registers */ 217 dev->sc_config1 = (dev->sc_host_id & ESC_CFG1_BUS_ID_MASK); 218 dev->sc_config2 = ESC_CFG2_FEATURES_ENABLE; 219 dev->sc_config3 = (dev->sc_clock_freq > 25 ? ESC_CFG3_FASTCLK : 0); 220 221/* Precalculate timeout value and clock period. */ 222/* Ekkk ... floating point in the kernel !!!! */ 223/* dev->sc_timeout_val = 1+dev->sc_timeout*dev->sc_clock_freq/ 224 (7.682*dev->sc_clock_conv_fact);*/ 225 dev->sc_timeout_val = 1+dev->sc_timeout*dev->sc_clock_freq/ 226 ((7682*dev->sc_clock_conv_fact)/1000); 227 dev->sc_clock_period = 1000/dev->sc_clock_freq; 228 229 escreset(dev, 1 | 2); /* Reset Chip and Bus */ 230 231 dev->sc_units_disconnected = 0; 232 dev->sc_msg_in_len = 0; 233 dev->sc_msg_out_len = 0; 234 235 dev->sc_flags = 0; 236 237 for(i=0; i<8; i++) 238 esc_init_nexus(dev, &dev->sc_nexus[i]); 239 240/* 241 * Setup bump buffer. 242 */ 243 dev->sc_bump_va = (u_char *)uvm_km_alloc(kernel_map, dev->sc_bump_sz, 0, 244 UVM_KMF_WIRED | UVM_KMF_ZERO); 245 (void) pmap_extract(pmap_kernel(), (vaddr_t)dev->sc_bump_va, 246 (paddr_t *)&dev->sc_bump_pa); 247 248/* 249 * Setup pages to noncachable, that way we don't have to flush the cache 250 * every time we need "bumped" transfer. 251 */ 252 pte = vtopte((vaddr_t) dev->sc_bump_va); 253 *pte &= ~L2_C; 254 PTE_SYNC(pte); 255 cpu_tlb_flushD(); 256 cpu_dcache_wbinv_range((vm_offset_t)dev->sc_bump_va, PAGE_SIZE); 257 258 printf(" dmabuf V0x%08x P0x%08x", (u_int)dev->sc_bump_va, (u_int)dev->sc_bump_pa); 259} 260 261 262/* 263 * used by specific esc controller 264 */ 265void 266esc_scsi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req, 267 void *arg) 268{ 269 struct scsipi_xfer *xs; 270 struct esc_softc *dev = (void *)chan->chan_adapter->adapt_dev; 271 struct scsipi_periph *periph; 272 struct esc_pending *pendp; 273 int flags, s, target; 274 275 switch (req) { 276 case ADAPTER_REQ_RUN_XFER: 277 xs = arg; 278 periph = xs->xs_periph; 279 flags = xs->xs_control; 280 target = periph->periph_target; 281 282 if (flags & XS_CTL_DATA_UIO) 283 panic("esc: scsi data uio requested"); 284 285 if ((flags & XS_CTL_POLL) && (dev->sc_flags & ESC_ACTIVE)) 286 panic("esc_scsicmd: busy"); 287 288/* Get hold of a esc_pending block. */ 289 s = splbio(); 290 pendp = dev->sc_xs_free.tqh_first; 291 if (pendp == NULL) { 292 splx(s); 293 xs->error = XS_RESOURCE_SHORTAGE; 294 scsipi_done(xs); 295 return; 296 } 297 TAILQ_REMOVE(&dev->sc_xs_free, pendp, link); 298 pendp->xs = xs; 299 splx(s); 300 301 302/* If the chip if busy OR the unit is busy, we have to wait for out turn. */ 303 if ((dev->sc_flags & ESC_ACTIVE) || 304 (dev->sc_nexus[target].flags & ESC_NF_UNIT_BUSY)) { 305 s = splbio(); 306 TAILQ_INSERT_TAIL(&dev->sc_xs_pending, pendp, link); 307 splx(s); 308 } else 309 esc_donextcmd(dev, pendp); 310 311 return; 312 case ADAPTER_REQ_GROW_RESOURCES: 313 case ADAPTER_REQ_SET_XFER_MODE: 314 /* XXX Not supported. */ 315 return; 316 } 317 318} 319 320/* 321 * Actually select the unit, whereby the whole scsi-process is started. 322 */ 323void 324esc_donextcmd(struct esc_softc *dev, struct esc_pending *pendp) 325{ 326 int s; 327 328/* 329 * Special case for scsi unit reset. I think this is waterproof. We first 330 * select the unit during splbio. We then cycle through the generated 331 * interrupts until the interrupt routine signals that the unit has 332 * acknowledged the reset. After that we have to wait a reset to select 333 * delay before anything else can happend. 334 */ 335 if (pendp->xs->xs_control & XS_CTL_RESET) { 336 struct nexus *nexus; 337 338 s = splbio(); 339 while(!escselect(dev, pendp, 0, 0, 0, 0, ESC_SELECT_K)) { 340 splx(s); 341 delay(10); 342 s = splbio(); 343 } 344 345 nexus = dev->sc_cur_nexus; 346 while(nexus->flags & ESC_NF_UNIT_BUSY) { 347 esciwait(dev); 348 escintr(dev); 349 } 350 351 nexus->flags |= ESC_NF_UNIT_BUSY; 352 splx(s); 353 354 escreset(dev, 0); 355 356 s = splbio(); 357 nexus->flags &= ~ESC_NF_UNIT_BUSY; 358 splx(s); 359 } 360 361/* 362 * If we are polling, go to splbio and perform the command, else we poke 363 * the scsi-bus via escgo to get the interrupt machine going. 364 */ 365 if (pendp->xs->xs_control & XS_CTL_POLL) { 366 s = splbio(); 367 escicmd(dev, pendp); 368 TAILQ_INSERT_TAIL(&dev->sc_xs_free, pendp, link); 369 splx(s); 370 } else { 371 escgo(dev, pendp); 372 return; 373 } 374} 375 376void 377esc_scsidone(struct esc_softc *dev, struct scsipi_xfer *xs, int stat) 378{ 379 struct esc_pending *pendp; 380 int s; 381 382 xs->status = stat; 383 384 if (stat == 0) 385 xs->resid = 0; 386 else { 387 switch(stat) { 388 case SCSI_CHECK: 389 case SCSI_BUSY: 390 xs->error = XS_BUSY; 391 break; 392 case -1: 393 xs->error = XS_DRIVER_STUFFUP; 394 QPRINTF(("esc_scsicmd() bad %x\n", stat)); 395 break; 396 default: 397 xs->error = XS_TIMEOUT; 398 break; 399 } 400 } 401 402/* Steal the next command from the queue so that one unit can't hog the bus. */ 403 s = splbio(); 404 pendp = dev->sc_xs_pending.tqh_first; 405 while(pendp) { 406 if (!(dev->sc_nexus[pendp->xs->xs_periph->periph_target].flags & 407 ESC_NF_UNIT_BUSY)) 408 break; 409 pendp = pendp->link.tqe_next; 410 } 411 412 if (pendp != NULL) { 413 TAILQ_REMOVE(&dev->sc_xs_pending, pendp, link); 414 } 415 416 splx(s); 417 scsipi_done(xs); 418 419 if (pendp) 420 esc_donextcmd(dev, pendp); 421} 422 423/* 424 * There are two kinds of reset: 425 * 1) CHIP-bus reset. This also implies a SCSI-bus reset. 426 * 2) SCSI-bus reset. 427 * After the appropriate resets have been performed we wait a reset to select 428 * delay time. 429 */ 430void 431escreset(struct esc_softc *dev, int how) 432{ 433 esc_regmap_p rp; 434 int i, s; 435 436 rp = dev->sc_esc; 437 438 if (how & 1) { 439 for(i=0; i<8; i++) 440 esc_init_nexus(dev, &dev->sc_nexus[i]); 441 442 *rp->esc_command = ESC_CMD_RESET_CHIP; 443 delay(1); 444 *rp->esc_command = ESC_CMD_NOP; 445 446 *rp->esc_config1 = dev->sc_config1; 447 *rp->esc_config2 = dev->sc_config2; 448 *rp->esc_config3 = dev->sc_config3; 449 *rp->esc_config4 = dev->sc_config4; 450 *rp->esc_timeout = dev->sc_timeout_val; 451 *rp->esc_clkconv = dev->sc_clock_conv_fact & 452 ESC_CLOCK_CONVERSION_MASK; 453 } 454 455 if (how & 2) { 456 for(i=0; i<8; i++) 457 esc_init_nexus(dev, &dev->sc_nexus[i]); 458 459 s = splbio(); 460 461 *rp->esc_command = ESC_CMD_RESET_SCSI_BUS; 462 delay(100); 463 464/* Skip interrupt generated by RESET_SCSI_BUS */ 465 while(*rp->esc_status & ESC_STAT_INTERRUPT_PENDING) { 466 dev->sc_status = *rp->esc_status; 467 dev->sc_interrupt = *rp->esc_interrupt; 468 469 delay(100); 470 } 471 472 dev->sc_status = *rp->esc_status; 473 dev->sc_interrupt = *rp->esc_interrupt; 474 475 splx(s); 476 } 477 478 if (dev->sc_config_flags & ESC_SLOW_START) 479 delay(4*250000); /* RESET to SELECT DELAY*4 for slow devices */ 480 else 481 delay(250000); /* RESET to SELECT DELAY */ 482} 483 484/* 485 * Save active data pointers to the nexus block currently active. 486 */ 487void 488esc_save_pointers(struct esc_softc *dev) 489{ 490 struct nexus *nx; 491 492 nx = dev->sc_cur_nexus; 493 if (nx) { 494 nx->cur_link = dev->sc_cur_link; 495 nx->max_link = dev->sc_max_link; 496 nx->buf = dev->sc_buf; 497 nx->len = dev->sc_len; 498 nx->dma_len = dev->sc_dma_len; 499 nx->dma_buf = dev->sc_dma_buf; 500 nx->dma_blk_flg = dev->sc_dma_blk_flg; 501 nx->dma_blk_len = dev->sc_dma_blk_len; 502 nx->dma_blk_ptr = dev->sc_dma_blk_ptr; 503 } 504} 505 506/* 507 * Restore data pointers from the currently active nexus block. 508 */ 509void 510esc_restore_pointers(struct esc_softc *dev) 511{ 512 struct nexus *nx; 513 514 nx = dev->sc_cur_nexus; 515 if (nx) { 516 dev->sc_cur_link = nx->cur_link; 517 dev->sc_max_link = nx->max_link; 518 dev->sc_buf = nx->buf; 519 dev->sc_len = nx->len; 520 dev->sc_dma_len = nx->dma_len; 521 dev->sc_dma_buf = nx->dma_buf; 522 dev->sc_dma_blk_flg = nx->dma_blk_flg; 523 dev->sc_dma_blk_len = nx->dma_blk_len; 524 dev->sc_dma_blk_ptr = nx->dma_blk_ptr; 525 dev->sc_chain = nx->dma; 526 dev->sc_unit = (nx->lun_unit & 0x0F); 527 dev->sc_lun = (nx->lun_unit & 0xF0) >> 4; 528 } 529} 530 531/* 532 * esciwait is used during interrupt and polled IO to wait for an event from 533 * the FAS chip. This function MUST NOT BE CALLED without interrupt disabled. 534 */ 535void 536esciwait(struct esc_softc *dev) 537{ 538 esc_regmap_p rp; 539 540/* 541 * If ESC_DONT_WAIT is set, we have already grabbed the interrupt info 542 * elsewhere. So we don't have to wait for it. 543 */ 544 if (dev->sc_flags & ESC_DONT_WAIT) { 545 dev->sc_flags &= ~ESC_DONT_WAIT; 546 return; 547 } 548 549 rp = dev->sc_esc; 550 551/* Wait for FAS chip to signal an interrupt. */ 552 while(!(*rp->esc_status & ESC_STAT_INTERRUPT_PENDING)); 553/* delay(1);*/ 554 555/* Grab interrupt info from chip. */ 556 dev->sc_status = *rp->esc_status; 557 dev->sc_interrupt = *rp->esc_interrupt; 558 if (dev->sc_interrupt & ESC_INT_RESELECTED) { 559 dev->sc_resel[0] = *rp->esc_fifo; 560 dev->sc_resel[1] = *rp->esc_fifo; 561 } 562} 563 564#if 0 565/* 566 * Transfer info to/from device. esc_ixfer uses polled IO+esciwait so the 567 * rules that apply to esciwait also applies here. 568 */ 569void 570esc_ixfer(struct esc_softc *dev) 571{ 572 esc_regmap_p rp; 573 u_char *buf; 574 int len, mode, phase; 575 576 rp = dev->sc_esc; 577 buf = dev->sc_buf; 578 len = dev->sc_len; 579 580/* 581 * Decode the scsi phase to determine whether we are reading or writing. 582 * mode == 1 => READ, mode == 0 => WRITE 583 */ 584 phase = dev->sc_status & ESC_STAT_PHASE_MASK; 585 mode = (phase == ESC_PHASE_DATA_IN); 586 587 while(len && ((dev->sc_status & ESC_STAT_PHASE_MASK) == phase)) 588 if (mode) { 589 *rp->esc_command = ESC_CMD_TRANSFER_INFO; 590 591 esciwait(dev); 592 593 *buf++ = *rp->esc_fifo; 594 len--; 595 } else { 596 len--; 597 *rp->esc_fifo = *buf++; 598 *rp->esc_command = ESC_CMD_TRANSFER_INFO; 599 600 esciwait(dev); 601 } 602 603/* Update buffer pointers to reflect the sent/received data. */ 604 dev->sc_buf = buf; 605 dev->sc_len = len; 606 607/* 608 * Since the last esciwait will be a phase-change, we can't wait for it 609 * again later, so we have to signal that. 610 */ 611 612 dev->sc_flags |= ESC_DONT_WAIT; 613} 614#else 615/* 616 * Transfer info to/from device. esc_ixfer uses polled IO+esciwait so the 617 * rules that apply to esciwait also applies here. 618 */ 619void 620esc_ixfer(struct esc_softc *dev) 621{ 622 esc_regmap_p rp; 623 vu_char *esc_status; 624 vu_char *esc_command; 625 vu_char *esc_interrupt; 626 vu_char *esc_fifo; 627 u_char *buf; 628 int len, mode, phase; 629 630 rp = dev->sc_esc; 631 buf = dev->sc_buf; 632 len = dev->sc_len; 633 634 /* Use discrete variables for better optimisation */ 635 636 esc_status = rp->esc_status; 637 esc_command = rp->esc_command; 638 esc_interrupt = rp->esc_interrupt; 639 esc_fifo = rp->esc_fifo; 640 641/* 642 * Decode the scsi phase to determine whether we are reading or writing. 643 * mode == 1 => READ, mode == 0 => WRITE 644 */ 645 phase = dev->sc_status & ESC_STAT_PHASE_MASK; 646 mode = (phase == ESC_PHASE_DATA_IN); 647 648 if (mode) { 649 while(len && ((dev->sc_status & ESC_STAT_PHASE_MASK) == phase)) { 650 *esc_command = ESC_CMD_TRANSFER_INFO; 651 652 /* Wait for FAS chip to signal an interrupt. */ 653 while(!(*esc_status & ESC_STAT_INTERRUPT_PENDING)); 654/* delay(1);*/ 655 656 /* Grab interrupt info from chip. */ 657 dev->sc_status = *esc_status; 658 dev->sc_interrupt = *esc_interrupt; 659 660 *buf++ = *esc_fifo; 661 len--; 662 } 663 } else { 664 while(len && ((dev->sc_status & ESC_STAT_PHASE_MASK) == phase)) { 665 len--; 666 *esc_fifo = *buf++; 667 *esc_command = ESC_CMD_TRANSFER_INFO; 668 669 /* Wait for FAS chip to signal an interrupt. */ 670 while(!(*esc_status & ESC_STAT_INTERRUPT_PENDING)); 671/* delay(1);*/ 672 673 /* Grab interrupt info from chip. */ 674 dev->sc_status = *esc_status; 675 dev->sc_interrupt = *esc_interrupt; 676 } 677 } 678 679/* Update buffer pointers to reflect the sent/received data. */ 680 dev->sc_buf = buf; 681 dev->sc_len = len; 682 683/* 684 * Since the last esciwait will be a phase-change, we can't wait for it 685 * again later, so we have to signal that. 686 */ 687 688 dev->sc_flags |= ESC_DONT_WAIT; 689} 690#endif 691 692/* 693 * Build a Synchronous Data Transfer Request message 694 */ 695void 696esc_build_sdtrm(struct esc_softc *dev, int period, int offset) 697{ 698 dev->sc_msg_out[0] = 0x01; 699 dev->sc_msg_out[1] = 0x03; 700 dev->sc_msg_out[2] = 0x01; 701 dev->sc_msg_out[3] = period/4; 702 dev->sc_msg_out[4] = offset; 703 dev->sc_msg_out_len= 5; 704} 705 706/* 707 * Arbitate the scsi bus and select the unit 708 */ 709int 710esc_select_unit(struct esc_softc *dev, short target) 711{ 712 esc_regmap_p rp; 713 struct nexus *nexus; 714 int s, retcode, i; 715 u_char cmd; 716 717 s = splbio(); /* Do this at splbio so that we won't be disturbed. */ 718 719 retcode = 0; 720 721 nexus = &dev->sc_nexus[target]; 722 723/* 724 * Check if the chip is busy. If not the we mark it as so and hope that nobody 725 * reselects us until we have grabbed the bus. 726 */ 727 if (!(dev->sc_flags & ESC_ACTIVE) && !dev->sc_sel_nexus) { 728 dev->sc_flags |= ESC_ACTIVE; 729 730 rp = dev->sc_esc; 731 732 *rp->esc_syncper = nexus->syncper; 733 *rp->esc_syncoff = nexus->syncoff; 734 *rp->esc_config3 = nexus->config3; 735 736 *rp->esc_config1 = dev->sc_config1; 737 *rp->esc_timeout = dev->sc_timeout_val; 738 *rp->esc_dest_id = target; 739 740/* If nobody has stolen the bus, we can send a select command to the chip. */ 741 if (!(*rp->esc_status & ESC_STAT_INTERRUPT_PENDING)) { 742 *rp->esc_fifo = nexus->ID; 743 if ((nexus->flags & (ESC_NF_DO_SDTR | ESC_NF_RESET)) 744 || (dev->sc_msg_out_len != 0)) 745 cmd = ESC_CMD_SEL_ATN_STOP; 746 else { 747 for(i=0; i<nexus->clen; i++) 748 *rp->esc_fifo = nexus->cbuf[i]; 749 750 cmd = ESC_CMD_SEL_ATN; 751 } 752 753 dev->sc_sel_nexus = nexus; 754 755 *rp->esc_command = cmd; 756 retcode = 1; 757 nexus->flags &= ~ESC_NF_RETRY_SELECT; 758 } else 759 nexus->flags |= ESC_NF_RETRY_SELECT; 760 } else 761 nexus->flags |= ESC_NF_RETRY_SELECT; 762 763 splx(s); 764 return(retcode); 765} 766 767/* 768 * Grab the nexus if available else return 0. 769 */ 770struct nexus * 771esc_arbitate_target(struct esc_softc *dev, int target) 772{ 773 struct nexus *nexus; 774 int s; 775 776/* 777 * This is realy simple. Raise interrupt level to splbio. Grab the nexus and 778 * leave. 779 */ 780 nexus = &dev->sc_nexus[target]; 781 782 s = splbio(); 783 784 if (nexus->flags & ESC_NF_UNIT_BUSY) 785 nexus = 0; 786 else 787 nexus->flags |= ESC_NF_UNIT_BUSY; 788 789 splx(s); 790 return(nexus); 791} 792 793/* 794 * Setup a nexus for use. Initializes command, buffer pointers and DMA chain. 795 */ 796void 797esc_setup_nexus(struct esc_softc *dev, struct nexus *nexus, struct esc_pending *pendp, unsigned char *cbuf, int clen, unsigned char *buf, int len, int mode) 798{ 799 int sync, target, lun; 800 801 target = pendp->xs->xs_periph->periph_target; 802 lun = pendp->xs->xs_periph->periph_lun; 803 804/* 805 * Adopt mode to reflect the config flags. 806 * If we can't use DMA we can't use synch transfer. Also check the 807 * esc_inhibit_xxx[target] flags. 808 */ 809 if ((dev->sc_config_flags & (ESC_NO_SYNCH | ESC_NO_DMA)) || 810 esc_inhibit_sync[(int)target]) 811 mode &= ~ESC_SELECT_S; 812 813 if ((dev->sc_config_flags & ESC_NO_RESELECT) || 814 esc_inhibit_disc[(int)target]) 815 mode &= ~ESC_SELECT_R; 816 817 nexus->xs = pendp->xs; 818 819/* Setup the nexus struct. */ 820 nexus->ID = ((mode & ESC_SELECT_R) ? 0xC0 : 0x80) | lun; 821 nexus->clen = clen; 822 memcpy(nexus->cbuf, cbuf, nexus->clen); 823 nexus->cbuf[1] |= lun << 5; /* Fix the lun bits */ 824 nexus->cur_link = 0; 825 nexus->dma_len = 0; 826 nexus->dma_buf = 0; 827 nexus->dma_blk_len = 0; 828 nexus->dma_blk_ptr = 0; 829 nexus->len = len; 830 nexus->buf = buf; 831 nexus->lun_unit = (lun << 4) | target; 832 nexus->state = ESC_NS_SELECTED; 833 834/* We must keep these flags. All else must be zero. */ 835 nexus->flags &= ESC_NF_UNIT_BUSY 836 | ESC_NF_SYNC_TESTED | ESC_NF_SELECT_ME; 837 838 if (mode & ESC_SELECT_I) 839 nexus->flags |= ESC_NF_IMMEDIATE; 840 if (mode & ESC_SELECT_K) 841 nexus->flags |= ESC_NF_RESET; 842 843 sync = ((mode & ESC_SELECT_S) ? 1 : 0); 844 845/* We can't use sync during polled IO. */ 846 if (sync && (mode & ESC_SELECT_I)) 847 sync = 0; 848 849 if (!sync && 850 ((nexus->flags & ESC_NF_SYNC_TESTED) && (nexus->offset != 0))) { 851 /* 852 * If the scsi unit is set to synch transfer and we don't want 853 * that, we have to renegotiate. 854 */ 855 856 nexus->flags |= ESC_NF_DO_SDTR; 857 nexus->period = 200; 858 nexus->offset = 0; 859 } else if (sync && !(nexus->flags & ESC_NF_SYNC_TESTED)) { 860 /* 861 * If the scsi unit is not set to synch transfer and we want 862 * that, we have to negotiate. This should realy base the 863 * period on the clock frequence rather than just check if 864 * >25 MHz 865 */ 866 867 nexus->flags |= ESC_NF_DO_SDTR; 868 nexus->period = ((dev->sc_clock_freq>25) ? 100 : 200); 869 nexus->offset = 8; 870 871 /* If the user has a long cable, we want to limit the period */ 872 if ((nexus->period == 100) && 873 (dev->sc_config_flags & ESC_SLOW_CABLE)) 874 nexus->period = 200; 875 } 876 877/* 878 * Fake a DMA-block for polled IO. This way we can use the same code to handle 879 * reselection. Much nicer this way. 880 */ 881 if ((mode & ESC_SELECT_I) || (dev->sc_config_flags & ESC_NO_DMA)) { 882 nexus->dma[0].ptr = buf; 883 nexus->dma[0].len = len; 884 nexus->dma[0].flg = ESC_CHAIN_PRG; 885 nexus->max_link = 1; 886 } else { 887 nexus->max_link = dev->sc_build_dma_chain(dev, nexus->dma, 888 buf, len); 889 } 890 891/* Flush the caches. */ 892 893 if (len && !(mode & ESC_SELECT_I)) 894 cpu_dcache_wbinv_range((vm_offset_t)buf, len); 895} 896 897int 898escselect(struct esc_softc *dev, struct esc_pending *pendp, unsigned char *cbuf, int clen, unsigned char *buf, int len, int mode) 899{ 900 struct nexus *nexus; 901 902/* Get the nexus struct. */ 903 nexus = esc_arbitate_target(dev, pendp->xs->xs_periph->periph_target); 904 if (nexus == NULL) 905 return(0); 906 907/* Setup the nexus struct. */ 908 esc_setup_nexus(dev, nexus, pendp, cbuf, clen, buf, len, mode); 909 910/* Post it to the interrupt machine. */ 911 esc_select_unit(dev, pendp->xs->xs_periph->periph_target); 912 913 return(1); 914} 915 916int 917escgo(struct esc_softc *dev, struct esc_pending *pendp) 918{ 919 int s; 920 char *buf; 921 922 buf = pendp->xs->data; 923 924 if (escselect(dev, pendp, (char *)pendp->xs->cmd, pendp->xs->cmdlen, 925 buf, pendp->xs->datalen, ESC_SELECT_RS)) { 926 /* 927 * We got the command going so the esc_pending struct is now 928 * free to reuse. 929 */ 930 931 s = splbio(); 932 TAILQ_INSERT_TAIL(&dev->sc_xs_free, pendp, link); 933 splx(s); 934 } else { 935 /* 936 * We couldn't make the command fly so we have to wait. The 937 * struct MUST be inserted at the head to keep the order of 938 * the commands. 939 */ 940 941 s = splbio(); 942 TAILQ_INSERT_HEAD(&dev->sc_xs_pending, pendp, link); 943 splx(s); 944 } 945 946 return(0); 947} 948 949/* 950 * Part one of the interrupt machine. Error checks and reselection test. 951 * We don't know if we have an active nexus here! 952 */ 953int 954esc_pretests(struct esc_softc *dev, esc_regmap_p rp) 955{ 956 struct nexus *nexus; 957 int i, s; 958 959 if (dev->sc_interrupt & ESC_INT_SCSI_RESET_DETECTED) { 960 /* 961 * Cleanup and notify user. Lets hope that this is all we 962 * have to do 963 */ 964 965 for(i=0; i<8; i++) { 966 if (dev->sc_nexus[i].xs) 967 esc_scsidone(dev, dev->sc_nexus[i].xs, -2); 968 969 esc_init_nexus(dev, &dev->sc_nexus[i]); 970 } 971 printf("escintr: SCSI-RESET detected!"); 972 return(-1); 973 } 974 975 if (dev->sc_interrupt & ESC_INT_ILLEGAL_COMMAND) { 976 /* Something went terrible wrong! Dump some data and panic! */ 977 978 printf("FIFO:"); 979 while(*rp->esc_fifo_flags & ESC_FIFO_COUNT_MASK) 980 printf(" %x", *rp->esc_fifo); 981 printf("\n"); 982 983 printf("CMD: %x\n", *rp->esc_command); 984 panic("escintr: ILLEGAL COMMAND!"); 985 } 986 987 if (dev->sc_interrupt & ESC_INT_RESELECTED) { 988 /* We were reselected. Set the chip as busy */ 989 990 s = splbio(); 991 dev->sc_flags |= ESC_ACTIVE; 992 if (dev->sc_sel_nexus) { 993 dev->sc_sel_nexus->flags |= ESC_NF_SELECT_ME; 994 dev->sc_sel_nexus = 0; 995 } 996 splx(s); 997 998 if (dev->sc_units_disconnected) { 999 /* Find out who reselected us. */ 1000 1001 dev->sc_resel[0] &= ~(1<<dev->sc_host_id); 1002 1003 for(i=0; i<8; i++) 1004 if (dev->sc_resel[0] & (1<<i)) 1005 break; 1006 1007 if (i == 8) 1008 panic("Illegal reselection!"); 1009 1010 if (dev->sc_nexus[i].state == ESC_NS_DISCONNECTED) { 1011 /* 1012 * This unit had disconnected, so we reconnect 1013 * it. 1014 */ 1015 1016 dev->sc_cur_nexus = &dev->sc_nexus[i]; 1017 nexus = dev->sc_cur_nexus; 1018 1019 *rp->esc_syncper = nexus->syncper; 1020 *rp->esc_syncoff = nexus->syncoff; 1021 *rp->esc_config3 = nexus->config3; 1022 1023 *rp->esc_dest_id = i & 7; 1024 1025 dev->sc_units_disconnected--; 1026 dev->sc_msg_in_len= 0; 1027 1028 /* Restore active pointers. */ 1029 esc_restore_pointers(dev); 1030 1031 nexus->state = ESC_NS_RESELECTED; 1032 1033 *rp->esc_command = ESC_CMD_MESSAGE_ACCEPTED; 1034 1035 return(1); 1036 } 1037 } 1038 1039 /* Somehow we got an illegal reselection. Dump and panic. */ 1040 printf("escintr: resel[0] %x resel[1] %x disconnected %d\n", 1041 dev->sc_resel[0], dev->sc_resel[1], 1042 dev->sc_units_disconnected); 1043 panic("escintr: Unexpected reselection!"); 1044 } 1045 1046 return(0); 1047} 1048 1049/* 1050 * Part two of the interrupt machine. Handle disconnection and post command 1051 * processing. We know that we have an active nexus here. 1052 */ 1053int 1054esc_midaction(struct esc_softc *dev, esc_regmap_p rp, struct nexus *nexus) 1055{ 1056 int i, left, len, s; 1057 u_char status, msg; 1058 1059 if (dev->sc_interrupt & ESC_INT_DISCONNECT) { 1060 s = splbio(); 1061 dev->sc_cur_nexus = 0; 1062 1063 /* Mark chip as busy and clean up the chip FIFO. */ 1064 dev->sc_flags &= ~ESC_ACTIVE; 1065 *rp->esc_command = ESC_CMD_FLUSH_FIFO; 1066 1067 /* Let the nexus state reflect what we have to do. */ 1068 switch(nexus->state) { 1069 case ESC_NS_SELECTED: 1070 dev->sc_sel_nexus = 0; 1071 nexus->flags &= ~ESC_NF_SELECT_ME; 1072 1073 /* 1074 * We were trying to select the unit. Probably no unit 1075 * at this ID. 1076 */ 1077 nexus->xs->resid = dev->sc_len; 1078 1079 nexus->status = -2; 1080 nexus->flags &= ~ESC_NF_UNIT_BUSY; 1081 nexus->state = ESC_NS_FINISHED; 1082 break; 1083 1084 case ESC_NS_DONE: 1085 /* All done. */ 1086 nexus->xs->resid = dev->sc_len; 1087 1088 nexus->flags &= ~ESC_NF_UNIT_BUSY; 1089 nexus->state = ESC_NS_FINISHED; 1090 dev->sc_led(dev, 0); 1091 break; 1092 1093 case ESC_NS_DISCONNECTING: 1094 /* 1095 * We have received a DISCONNECT message, so we are 1096 * doing a normal disconnection. 1097 */ 1098 nexus->state = ESC_NS_DISCONNECTED; 1099 1100 dev->sc_units_disconnected++; 1101 break; 1102 1103 case ESC_NS_RESET: 1104 /* 1105 * We were reseting this SCSI-unit. Clean up the 1106 * nexus struct. 1107 */ 1108 dev->sc_led(dev, 0); 1109 esc_init_nexus(dev, nexus); 1110 break; 1111 1112 default: 1113 /* 1114 * Unexpected disconnection! Cleanup and exit. This 1115 * shouldn't cause any problems. 1116 */ 1117 printf("escintr: Unexpected disconnection\n"); 1118 printf("escintr: u %x s %d p %d f %x c %x\n", 1119 nexus->lun_unit, nexus->state, 1120 dev->sc_status & ESC_STAT_PHASE_MASK, 1121 nexus->flags, nexus->cbuf[0]); 1122 1123 nexus->xs->resid = dev->sc_len; 1124 1125 nexus->flags &= ~ESC_NF_UNIT_BUSY; 1126 nexus->state = ESC_NS_FINISHED; 1127 nexus->status = -3; 1128 1129 dev->sc_led(dev, 0); 1130 break; 1131 } 1132 1133 /* 1134 * If we have disconnected units, we MUST enable reselection 1135 * within 250ms. 1136 */ 1137 if (dev->sc_units_disconnected && 1138 !(dev->sc_flags & ESC_ACTIVE)) 1139 *rp->esc_command = ESC_CMD_ENABLE_RESEL; 1140 1141 splx(s); 1142 1143 /* Select the first pre-initialized nexus we find. */ 1144 for(i=0; i<8; i++) 1145 if (dev->sc_nexus[i].flags & (ESC_NF_SELECT_ME | ESC_NF_RETRY_SELECT)) 1146 if (esc_select_unit(dev, i) == 2) 1147 break; 1148 1149 /* We are done with this nexus! */ 1150 if (nexus->state == ESC_NS_FINISHED) 1151 esc_scsidone(dev, nexus->xs, nexus->status); 1152 1153 return(1); 1154 } 1155 1156 switch(nexus->state) { 1157 case ESC_NS_SELECTED: 1158 dev->sc_cur_nexus = nexus; 1159 dev->sc_sel_nexus = 0; 1160 1161 nexus->flags &= ~ESC_NF_SELECT_ME; 1162 1163 /* 1164 * We have selected a unit. Setup chip, restore pointers and 1165 * light the led. 1166 */ 1167 *rp->esc_syncper = nexus->syncper; 1168 *rp->esc_syncoff = nexus->syncoff; 1169 *rp->esc_config3 = nexus->config3; 1170 1171 esc_restore_pointers(dev); 1172 1173 nexus->status = 0xFF; 1174 dev->sc_msg_in[0] = 0xFF; 1175 dev->sc_msg_in_len= 0; 1176 1177 dev->sc_led(dev, 1); 1178 1179 break; 1180 1181 case ESC_NS_DATA_IN: 1182 case ESC_NS_DATA_OUT: 1183 /* We have transfered data. */ 1184 if (dev->sc_dma_len) 1185 if (dev->sc_cur_link < dev->sc_max_link) { 1186 /* 1187 * Clean up DMA and at the same time get how 1188 * many bytes that were NOT transfered. 1189 */ 1190 left = dev->sc_setup_dma(dev, 0, 0, ESC_DMA_CLEAR); 1191 len = dev->sc_dma_len; 1192 1193 if (nexus->state == ESC_NS_DATA_IN) { 1194 /* 1195 * If we were bumping we may have had an odd length 1196 * which means that there may be bytes left in the 1197 * fifo. We also need to move the data from the 1198 * bump buffer to the actual memory. 1199 */ 1200 if (dev->sc_dma_buf == dev->sc_bump_pa) 1201 { 1202 while((*rp->esc_fifo_flags&ESC_FIFO_COUNT_MASK) 1203 && left) 1204 dev->sc_bump_va[len-(left--)] = *rp->esc_fifo; 1205 1206 memcpy(dev->sc_buf, dev->sc_bump_va, len-left); 1207 } 1208 } else { 1209 /* Count any unsent bytes and flush them. */ 1210 left+= *rp->esc_fifo_flags & ESC_FIFO_COUNT_MASK; 1211 *rp->esc_command = ESC_CMD_FLUSH_FIFO; 1212 } 1213 1214 /* 1215 * Update pointers/length to reflect the transfered 1216 * data. 1217 */ 1218 dev->sc_len -= len-left; 1219 dev->sc_buf += len-left; 1220 1221 dev->sc_dma_buf = (char *)dev->sc_dma_buf + len-left; 1222 dev->sc_dma_len = left; 1223 1224 dev->sc_dma_blk_ptr = (char *)dev->sc_dma_blk_ptr + 1225 len-left; 1226 dev->sc_dma_blk_len -= len-left; 1227 1228 /* 1229 * If it was the end of a DMA block, we select the 1230 * next to begin with. 1231 */ 1232 if (!dev->sc_dma_blk_len) 1233 dev->sc_cur_link++; 1234 } 1235 break; 1236 1237 case ESC_NS_STATUS: 1238 /* 1239 * If we were not sensing, grab the status byte. If we were 1240 * sensing and we got a bad status, let the user know. 1241 */ 1242 1243 status = *rp->esc_fifo; 1244 msg = *rp->esc_fifo; 1245 1246 nexus->status = status; 1247 if (status != 0) 1248 nexus->status = -1; 1249 1250 /* 1251 * Preload the command complete message. Handeled in 1252 * esc_postaction. 1253 */ 1254 dev->sc_msg_in[0] = msg; 1255 dev->sc_msg_in_len = 1; 1256 nexus->flags |= ESC_NF_HAS_MSG; 1257 break; 1258 1259 default: 1260 break; 1261 } 1262 1263 return(0); 1264} 1265 1266/* 1267 * Part three of the interrupt machine. Handle phase changes (and repeated 1268 * phase passes). We know that we have an active nexus here. 1269 */ 1270int 1271esc_postaction(struct esc_softc *dev, esc_regmap_p rp, struct nexus *nexus) 1272{ 1273 int i, len; 1274 u_char cmd; 1275 short offset, period; 1276 1277 cmd = 0; 1278 1279 switch(dev->sc_status & ESC_STAT_PHASE_MASK) { 1280 case ESC_PHASE_DATA_OUT: 1281 case ESC_PHASE_DATA_IN: 1282 if ((dev->sc_status & ESC_STAT_PHASE_MASK) == 1283 ESC_PHASE_DATA_OUT) 1284 nexus->state = ESC_NS_DATA_OUT; 1285 else 1286 nexus->state = ESC_NS_DATA_IN; 1287 1288 /* Make DMA ready to accept new data. Load active pointers 1289 * from the DMA block. */ 1290 dev->sc_setup_dma(dev, 0, 0, ESC_DMA_CLEAR); 1291 if (dev->sc_cur_link < dev->sc_max_link) { 1292 if (!dev->sc_dma_blk_len) { 1293 dev->sc_dma_blk_ptr = dev->sc_chain[dev->sc_cur_link].ptr; 1294 dev->sc_dma_blk_len = dev->sc_chain[dev->sc_cur_link].len; 1295 dev->sc_dma_blk_flg = dev->sc_chain[dev->sc_cur_link].flg; 1296 } 1297 1298 /* We should use polled IO here. */ 1299 if (dev->sc_dma_blk_flg == ESC_CHAIN_PRG) { 1300 esc_ixfer(dev/*, nexus->xs->xs_control & XS_CTL_POLL*/); 1301 dev->sc_cur_link++; 1302 dev->sc_dma_len = 0; 1303 break; 1304 } 1305 else if (dev->sc_dma_blk_flg == ESC_CHAIN_BUMP) 1306 len = dev->sc_dma_blk_len; 1307 else 1308 len = dev->sc_need_bump(dev, 1309 (void *)dev->sc_dma_blk_ptr, 1310 dev->sc_dma_blk_len); 1311 1312 /* 1313 * If len != 0 we must bump the data, else we just DMA it 1314 * straight into memory. 1315 */ 1316 if (len) { 1317 dev->sc_dma_buf = dev->sc_bump_pa; 1318 dev->sc_dma_len = len; 1319 1320 if (nexus->state == ESC_NS_DATA_OUT) 1321 memcpy(dev->sc_bump_va, dev->sc_buf, dev->sc_dma_len); 1322 } else { 1323 dev->sc_dma_buf = dev->sc_dma_blk_ptr; 1324 dev->sc_dma_len = dev->sc_dma_blk_len; 1325 } 1326 1327 /* Load DMA with address and length of transfer. */ 1328 dev->sc_setup_dma(dev, (void *)dev->sc_dma_buf, 1329 dev->sc_dma_len, 1330 ((nexus->state == ESC_NS_DATA_OUT) ? 1331 ESC_DMA_WRITE : ESC_DMA_READ)); 1332 1333 printf("Using DMA !!!!\n"); 1334 cmd = ESC_CMD_TRANSFER_INFO | ESC_CMD_DMA; 1335 } else { 1336 /* 1337 * Hmmm, the unit wants more info than we have or has 1338 * more than we want. Let the chip handle that. 1339 */ 1340 1341 *rp->esc_tc_low = 0; 1342 *rp->esc_tc_mid = 1; 1343 *rp->esc_tc_high = 0; 1344 cmd = ESC_CMD_TRANSFER_PAD; 1345 } 1346 break; 1347 1348 case ESC_PHASE_COMMAND: 1349 /* The scsi unit wants the command, send it. */ 1350 nexus->state = ESC_NS_SVC; 1351 1352 *rp->esc_command = ESC_CMD_FLUSH_FIFO; 1353 for(i=0; i<5; i++); 1354 1355 for(i=0; i<nexus->clen; i++) 1356 *rp->esc_fifo = nexus->cbuf[i]; 1357 cmd = ESC_CMD_TRANSFER_INFO; 1358 break; 1359 1360 case ESC_PHASE_STATUS: 1361 /* 1362 * We've got status phase. Request status and command 1363 * complete message. 1364 */ 1365 nexus->state = ESC_NS_STATUS; 1366 cmd = ESC_CMD_COMMAND_COMPLETE; 1367 break; 1368 1369 case ESC_PHASE_MESSAGE_OUT: 1370 /* 1371 * Either the scsi unit wants us to send a message or we have 1372 * asked for it by seting the ATN bit. 1373 */ 1374 nexus->state = ESC_NS_MSG_OUT; 1375 1376 *rp->esc_command = ESC_CMD_FLUSH_FIFO; 1377 1378 if (nexus->flags & ESC_NF_DO_SDTR) { 1379 /* Send a Synchronous Data Transfer Request. */ 1380 1381 esc_build_sdtrm(dev, nexus->period, nexus->offset); 1382 nexus->flags |= ESC_NF_SDTR_SENT; 1383 nexus->flags &= ~ESC_NF_DO_SDTR; 1384 } else if (nexus->flags & ESC_NF_RESET) { 1385 /* Send a reset scsi unit message. */ 1386 1387 dev->sc_msg_out[0] = 0x0C; 1388 dev->sc_msg_out_len = 1; 1389 nexus->state = ESC_NS_RESET; 1390 nexus->flags &= ~ESC_NF_RESET; 1391 } else if (dev->sc_msg_out_len == 0) { 1392 /* Don't know what to send so we send a NOP message. */ 1393 1394 dev->sc_msg_out[0] = 0x08; 1395 dev->sc_msg_out_len = 1; 1396 } 1397 1398 cmd = ESC_CMD_TRANSFER_INFO; 1399 1400 for(i=0; i<dev->sc_msg_out_len; i++) 1401 *rp->esc_fifo = dev->sc_msg_out[i]; 1402 dev->sc_msg_out_len = 0; 1403 1404 break; 1405 1406 case ESC_PHASE_MESSAGE_IN: 1407 /* Receive a message from the scsi unit. */ 1408 nexus->state = ESC_NS_MSG_IN; 1409 1410 while(!(nexus->flags & ESC_NF_HAS_MSG)) { 1411 *rp->esc_command = ESC_CMD_TRANSFER_INFO; 1412 esciwait(dev); 1413 1414 dev->sc_msg_in[dev->sc_msg_in_len++] = *rp->esc_fifo; 1415 1416 /* Check if we got all the bytes in the message. */ 1417 if (dev->sc_msg_in[0] >= 0x80) ; 1418 else if (dev->sc_msg_in[0] >= 0x30) ; 1419 else if (((dev->sc_msg_in[0] >= 0x20) && 1420 (dev->sc_msg_in_len == 2)) || 1421 ((dev->sc_msg_in[0] != 0x01) && 1422 (dev->sc_msg_in_len == 1))) { 1423 nexus->flags |= ESC_NF_HAS_MSG; 1424 break; 1425 } else { 1426 if (dev->sc_msg_in_len >= 2) 1427 if ((dev->sc_msg_in[1]+2) == dev->sc_msg_in_len) { 1428 nexus->flags |= ESC_NF_HAS_MSG; 1429 break; 1430 } 1431 } 1432 1433 *rp->esc_command = ESC_CMD_MESSAGE_ACCEPTED; 1434 esciwait(dev); 1435 1436 if ((dev->sc_status & ESC_STAT_PHASE_MASK) != 1437 ESC_PHASE_MESSAGE_IN) 1438 break; 1439 } 1440 1441 cmd = ESC_CMD_MESSAGE_ACCEPTED; 1442 if (nexus->flags & ESC_NF_HAS_MSG) { 1443 /* We have a message. Decode it. */ 1444 1445 switch(dev->sc_msg_in[0]) { 1446 case 0x00: /* COMMAND COMPLETE */ 1447 nexus->state = ESC_NS_DONE; 1448 case 0x04: /* DISCONNECT */ 1449 nexus->state = ESC_NS_DISCONNECTING; 1450 break; 1451 case 0x02: /* SAVE DATA POINTER */ 1452 esc_save_pointers(dev); 1453 break; 1454 case 0x03: /* RESTORE DATA POINTERS */ 1455 esc_restore_pointers(dev); 1456 break; 1457 case 0x07: /* MESSAGE REJECT */ 1458 /* 1459 * If we had sent a SDTR and we got a message 1460 * reject, the scsi docs say that we must go 1461 * to async transfer. 1462 */ 1463 if (nexus->flags & ESC_NF_SDTR_SENT) { 1464 nexus->flags &= ~ESC_NF_SDTR_SENT; 1465 1466 nexus->config3 &= ~ESC_CFG3_FASTSCSI; 1467 nexus->syncper = 5; 1468 nexus->syncoff = 0; 1469 1470 *rp->esc_syncper = nexus->syncper; 1471 *rp->esc_syncoff = nexus->syncoff; 1472 *rp->esc_config3 = nexus->config3; 1473 } else 1474 /* 1475 * Something was rejected but we don't know 1476 * what! PANIC! 1477 */ 1478 panic("escintr: Unknown message rejected!"); 1479 break; 1480 case 0x08: /* MO OPERATION */ 1481 break; 1482 case 0x01: /* EXTENDED MESSAGE */ 1483 switch(dev->sc_msg_in[2]) { 1484 case 0x01:/* SYNC. DATA TRANSFER REQUEST */ 1485 /* Decode the SDTR message. */ 1486 period = 4*dev->sc_msg_in[3]; 1487 offset = dev->sc_msg_in[4]; 1488 1489 /* 1490 * Make sure that the specs are within 1491 * chip limits. Note that if we 1492 * initiated the negotiation the specs 1493 * WILL be withing chip limits. If it 1494 * was the scsi unit that initiated 1495 * the negotiation, the specs may be 1496 * to high. 1497 */ 1498 if (offset > 16) 1499 offset = 16; 1500 if ((period < 200) && 1501 (dev->sc_clock_freq <= 25)) 1502 period = 200; 1503 1504 if (offset == 0) 1505 period = 5*dev->sc_clock_period; 1506 1507 nexus->syncper = period/ 1508 dev->sc_clock_period; 1509 nexus->syncoff = offset; 1510 1511 if (period < 200) 1512 nexus->config3 |= ESC_CFG3_FASTSCSI; 1513 else 1514 nexus->config3 &=~ESC_CFG3_FASTSCSI; 1515 1516 nexus->flags |= ESC_NF_SYNC_TESTED; 1517 1518 *rp->esc_syncper = nexus->syncper; 1519 *rp->esc_syncoff = nexus->syncoff; 1520 *rp->esc_config3 = nexus->config3; 1521 1522 /* 1523 * Hmmm, it seems that the scsi unit 1524 * initiated sync negotiation, so lets 1525 * reply acording to scsi-2 standard. 1526 */ 1527 if (!(nexus->flags& ESC_NF_SDTR_SENT)) 1528 { 1529 if ((dev->sc_config_flags & 1530 ESC_NO_SYNCH) || 1531 (dev->sc_config_flags & 1532 ESC_NO_DMA) || 1533 esc_inhibit_sync[ 1534 nexus->lun_unit & 7]) { 1535 period = 200; 1536 offset = 0; 1537 } 1538 1539 nexus->offset = offset; 1540 nexus->period = period; 1541 nexus->flags |= ESC_NF_DO_SDTR; 1542 *rp->esc_command = ESC_CMD_SET_ATN; 1543 } 1544 1545 nexus->flags &= ~ESC_NF_SDTR_SENT; 1546 break; 1547 1548 case 0x00: /* MODIFY DATA POINTERS */ 1549 case 0x02: /* EXTENDED IDENTIFY (SCSI-1) */ 1550 case 0x03: /* WIDE DATA TRANSFER REQUEST */ 1551 default: 1552 /* Reject any unhandeled messages. */ 1553 1554 dev->sc_msg_out[0] = 0x07; 1555 dev->sc_msg_out_len = 1; 1556 *rp->esc_command = ESC_CMD_SET_ATN; 1557 cmd = ESC_CMD_MESSAGE_ACCEPTED; 1558 break; 1559 } 1560 break; 1561 1562 default: 1563 /* Reject any unhandeled messages. */ 1564 1565 dev->sc_msg_out[0] = 0x07; 1566 dev->sc_msg_out_len = 1; 1567 *rp->esc_command = ESC_CMD_SET_ATN; 1568 cmd = ESC_CMD_MESSAGE_ACCEPTED; 1569 break; 1570 } 1571 nexus->flags &= ~ESC_NF_HAS_MSG; 1572 dev->sc_msg_in_len = 0; 1573 } 1574 break; 1575 default: 1576 printf("ESCINTR: UNKNOWN PHASE! phase: %d\n", 1577 dev->sc_status & ESC_STAT_PHASE_MASK); 1578 dev->sc_led(dev, 0); 1579 esc_scsidone(dev, nexus->xs, -4); 1580 1581 return(-1); 1582 } 1583 1584 if (cmd) 1585 *rp->esc_command = cmd; 1586 1587 return(0); 1588} 1589 1590/* 1591 * Stub for interrupt machine. 1592 */ 1593void 1594escintr(struct esc_softc *dev) 1595{ 1596 esc_regmap_p rp; 1597 struct nexus *nexus; 1598 1599 rp = dev->sc_esc; 1600 1601 if (!esc_pretests(dev, rp)) { 1602 1603 nexus = dev->sc_cur_nexus; 1604 if (nexus == NULL) 1605 nexus = dev->sc_sel_nexus; 1606 1607 if (nexus) 1608 if (!esc_midaction(dev, rp, nexus)) 1609 esc_postaction(dev, rp, nexus); 1610 } 1611} 1612 1613/* 1614 * escicmd is used to perform IO when we can't use interrupts. escicmd 1615 * emulates the normal environment by waiting for the chip and calling 1616 * escintr. 1617 */ 1618void 1619escicmd(struct esc_softc *dev, struct esc_pending *pendp) 1620{ 1621 esc_regmap_p rp; 1622 struct nexus *nexus; 1623 1624 nexus = &dev->sc_nexus[pendp->xs->xs_periph->periph_target]; 1625 rp = dev->sc_esc; 1626 1627 if (!escselect(dev, pendp, (char *)pendp->xs->cmd, pendp->xs->cmdlen, 1628 (char *)pendp->xs->data, pendp->xs->datalen, 1629 ESC_SELECT_I)) 1630 panic("escicmd: Couldn't select unit"); 1631 1632 while(nexus->state != ESC_NS_FINISHED) { 1633 esciwait(dev); 1634 escintr(dev); 1635 } 1636 1637 nexus->flags &= ~ESC_NF_SYNC_TESTED; 1638} 1639