1 /* $NetBSD: bha.c,v 1.65 2005/12/24 20:27:29 perry Exp $ */ 2 3 /*- 4 * Copyright (c) 1997, 1998, 1999 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace 9 * Simulation Facility, NASA Ames Research Center. 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 the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 /* 41 * Originally written by Julian Elischer (julian@tfs.com) 42 * for TRW Financial Systems for use under the MACH(2.5) operating system. 43 * 44 * TRW Financial Systems, in accordance with their agreement with Carnegie 45 * Mellon University, makes this software available to CMU to distribute 46 * or use in any manner that they see fit as long as this message is kept with 47 * the software. For this reason TFS also grants any other persons or 48 * organisations permission to use or modify this software. 49 * 50 * TFS supplies this software to be publicly redistributed 51 * on the understanding that TFS is not responsible for the correct 52 * functioning of this software in any circumstances. 53 */ 54 55 #include <sys/cdefs.h> 56 __KERNEL_RCSID(0, "$NetBSD: bha.c,v 1.65 2005/12/24 20:27:29 perry Exp $"); 57 58 #include "opt_ddb.h" 59 60 #include <sys/param.h> 61 #include <sys/systm.h> 62 #include <sys/callout.h> 63 #include <sys/kernel.h> 64 #include <sys/errno.h> 65 #include <sys/ioctl.h> 66 #include <sys/device.h> 67 #include <sys/malloc.h> 68 #include <sys/buf.h> 69 #include <sys/proc.h> 70 #include <sys/user.h> 71 72 #include <uvm/uvm_extern.h> 73 74 #include <machine/bus.h> 75 #include <machine/intr.h> 76 77 #include <dev/scsipi/scsi_all.h> 78 #include <dev/scsipi/scsipi_all.h> 79 #include <dev/scsipi/scsiconf.h> 80 81 #include <dev/ic/bhareg.h> 82 #include <dev/ic/bhavar.h> 83 84 #ifndef DDB 85 #define Debugger() panic("should call debugger here (bha.c)") 86 #endif /* ! DDB */ 87 88 #define BHA_MAXXFER ((BHA_NSEG - 1) << PGSHIFT) 89 90 #ifdef BHADEBUG 91 int bha_debug = 0; 92 #endif /* BHADEBUG */ 93 94 static int bha_cmd(bus_space_tag_t, bus_space_handle_t, const char *, int, 95 u_char *, int, u_char *); 96 97 static void bha_scsipi_request(struct scsipi_channel *, 98 scsipi_adapter_req_t, void *); 99 static void bha_minphys(struct buf *); 100 101 static void bha_get_xfer_mode(struct bha_softc *, 102 struct scsipi_xfer_mode *); 103 104 static void bha_done(struct bha_softc *, struct bha_ccb *); 105 static int bha_poll(struct bha_softc *, struct scsipi_xfer *, int); 106 static void bha_timeout(void *arg); 107 108 static int bha_init(struct bha_softc *); 109 110 static int bha_create_mailbox(struct bha_softc *); 111 static void bha_collect_mbo(struct bha_softc *); 112 113 static void bha_queue_ccb(struct bha_softc *, struct bha_ccb *); 114 static void bha_start_ccbs(struct bha_softc *); 115 static void bha_finish_ccbs(struct bha_softc *); 116 117 static struct bha_ccb *bha_ccb_phys_kv(struct bha_softc *, bus_addr_t); 118 static void bha_create_ccbs(struct bha_softc *, int); 119 static int bha_init_ccb(struct bha_softc *, struct bha_ccb *); 120 static struct bha_ccb *bha_get_ccb(struct bha_softc *); 121 static void bha_free_ccb(struct bha_softc *, struct bha_ccb *); 122 123 #define BHA_RESET_TIMEOUT 2000 /* time to wait for reset (mSec) */ 124 #define BHA_ABORT_TIMEOUT 2000 /* time to wait for abort (mSec) */ 125 126 /* 127 * Number of CCBs in an allocation group; must be computed at run-time. 128 */ 129 static int bha_ccbs_per_group; 130 131 static inline struct bha_mbx_out * 132 bha_nextmbo(struct bha_softc *sc, struct bha_mbx_out *mbo) 133 { 134 135 if (mbo == &sc->sc_mbo[sc->sc_mbox_count - 1]) 136 return (&sc->sc_mbo[0]); 137 return (mbo + 1); 138 } 139 140 static inline struct bha_mbx_in * 141 bha_nextmbi(struct bha_softc *sc, struct bha_mbx_in *mbi) 142 { 143 if (mbi == &sc->sc_mbi[sc->sc_mbox_count - 1]) 144 return (&sc->sc_mbi[0]); 145 return (mbi + 1); 146 } 147 148 /* 149 * bha_attach: 150 * 151 * Finish attaching a Buslogic controller, and configure children. 152 */ 153 void 154 bha_attach(struct bha_softc *sc) 155 { 156 struct scsipi_adapter *adapt = &sc->sc_adapter; 157 struct scsipi_channel *chan = &sc->sc_channel; 158 int initial_ccbs; 159 160 /* 161 * Initialize the number of CCBs per group. 162 */ 163 if (bha_ccbs_per_group == 0) 164 bha_ccbs_per_group = BHA_CCBS_PER_GROUP; 165 166 initial_ccbs = bha_info(sc); 167 if (initial_ccbs == 0) { 168 aprint_error("%s: unable to get adapter info\n", 169 sc->sc_dev.dv_xname); 170 return; 171 } 172 173 /* 174 * Fill in the scsipi_adapter. 175 */ 176 memset(adapt, 0, sizeof(*adapt)); 177 adapt->adapt_dev = &sc->sc_dev; 178 adapt->adapt_nchannels = 1; 179 /* adapt_openings initialized below */ 180 adapt->adapt_max_periph = sc->sc_mbox_count; 181 adapt->adapt_request = bha_scsipi_request; 182 adapt->adapt_minphys = bha_minphys; 183 184 /* 185 * Fill in the scsipi_channel. 186 */ 187 memset(chan, 0, sizeof(*chan)); 188 chan->chan_adapter = adapt; 189 chan->chan_bustype = &scsi_bustype; 190 chan->chan_channel = 0; 191 chan->chan_flags = SCSIPI_CHAN_CANGROW; 192 chan->chan_ntargets = (sc->sc_flags & BHAF_WIDE) ? 16 : 8; 193 chan->chan_nluns = (sc->sc_flags & BHAF_WIDE_LUN) ? 32 : 8; 194 chan->chan_id = sc->sc_scsi_id; 195 196 TAILQ_INIT(&sc->sc_free_ccb); 197 TAILQ_INIT(&sc->sc_waiting_ccb); 198 TAILQ_INIT(&sc->sc_allocating_ccbs); 199 200 if (bha_create_mailbox(sc) != 0) 201 return; 202 203 bha_create_ccbs(sc, initial_ccbs); 204 if (sc->sc_cur_ccbs < 2) { 205 aprint_error("%s: not enough CCBs to run\n", 206 sc->sc_dev.dv_xname); 207 return; 208 } 209 210 adapt->adapt_openings = sc->sc_cur_ccbs; 211 212 if (bha_init(sc) != 0) 213 return; 214 215 (void) config_found(&sc->sc_dev, &sc->sc_channel, scsiprint); 216 } 217 218 /* 219 * bha_intr: 220 * 221 * Interrupt service routine. 222 */ 223 int 224 bha_intr(void *arg) 225 { 226 struct bha_softc *sc = arg; 227 bus_space_tag_t iot = sc->sc_iot; 228 bus_space_handle_t ioh = sc->sc_ioh; 229 u_char sts; 230 231 #ifdef BHADEBUG 232 printf("%s: bha_intr ", sc->sc_dev.dv_xname); 233 #endif /* BHADEBUG */ 234 235 /* 236 * First acknowledge the interrupt, Then if it's not telling about 237 * a completed operation just return. 238 */ 239 sts = bus_space_read_1(iot, ioh, BHA_INTR_PORT); 240 if ((sts & BHA_INTR_ANYINTR) == 0) 241 return (0); 242 bus_space_write_1(iot, ioh, BHA_CTRL_PORT, BHA_CTRL_IRST); 243 244 #ifdef BHADIAG 245 /* Make sure we clear CCB_SENDING before finishing a CCB. */ 246 bha_collect_mbo(sc); 247 #endif 248 249 /* Mail box out empty? */ 250 if (sts & BHA_INTR_MBOA) { 251 struct bha_toggle toggle; 252 253 toggle.cmd.opcode = BHA_MBO_INTR_EN; 254 toggle.cmd.enable = 0; 255 bha_cmd(iot, ioh, sc->sc_dev.dv_xname, 256 sizeof(toggle.cmd), (u_char *)&toggle.cmd, 257 0, (u_char *)0); 258 bha_start_ccbs(sc); 259 } 260 261 /* Mail box in full? */ 262 if (sts & BHA_INTR_MBIF) 263 bha_finish_ccbs(sc); 264 265 return (1); 266 } 267 268 /***************************************************************************** 269 * SCSI interface routines 270 *****************************************************************************/ 271 272 /* 273 * bha_scsipi_request: 274 * 275 * Perform a request for the SCSIPI layer. 276 */ 277 static void 278 bha_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req, 279 void *arg) 280 { 281 struct scsipi_adapter *adapt = chan->chan_adapter; 282 struct bha_softc *sc = (void *)adapt->adapt_dev; 283 struct scsipi_xfer *xs; 284 struct scsipi_periph *periph; 285 bus_dma_tag_t dmat = sc->sc_dmat; 286 struct bha_ccb *ccb; 287 int error, seg, flags, s; 288 289 switch (req) { 290 case ADAPTER_REQ_RUN_XFER: 291 xs = arg; 292 periph = xs->xs_periph; 293 flags = xs->xs_control; 294 295 SC_DEBUG(periph, SCSIPI_DB2, ("bha_scsipi_request\n")); 296 297 /* Get a CCB to use. */ 298 ccb = bha_get_ccb(sc); 299 #ifdef DIAGNOSTIC 300 /* 301 * This should never happen as we track the resources 302 * in the mid-layer. 303 */ 304 if (ccb == NULL) { 305 scsipi_printaddr(periph); 306 printf("unable to allocate ccb\n"); 307 panic("bha_scsipi_request"); 308 } 309 #endif 310 311 ccb->xs = xs; 312 ccb->timeout = xs->timeout; 313 314 /* 315 * Put all the arguments for the xfer in the ccb 316 */ 317 if (flags & XS_CTL_RESET) { 318 ccb->opcode = BHA_RESET_CCB; 319 ccb->scsi_cmd_length = 0; 320 } else { 321 /* can't use S/G if zero length */ 322 if (xs->cmdlen > sizeof(ccb->scsi_cmd)) { 323 printf("%s: cmdlen %d too large for CCB\n", 324 sc->sc_dev.dv_xname, xs->cmdlen); 325 xs->error = XS_DRIVER_STUFFUP; 326 goto out_bad; 327 } 328 ccb->opcode = (xs->datalen ? BHA_INIT_SCAT_GATH_CCB 329 : BHA_INITIATOR_CCB); 330 memcpy(&ccb->scsi_cmd, xs->cmd, 331 ccb->scsi_cmd_length = xs->cmdlen); 332 } 333 334 if (xs->datalen) { 335 /* 336 * Map the DMA transfer. 337 */ 338 #ifdef TFS 339 if (flags & XS_CTL_DATA_UIO) { 340 error = bus_dmamap_load_uio(dmat, 341 ccb->dmamap_xfer, (struct uio *)xs->data, 342 ((flags & XS_CTL_NOSLEEP) ? BUS_DMA_NOWAIT : 343 BUS_DMA_WAITOK) | BUS_DMA_STREAMING | 344 ((flags & XS_CTL_DATA_IN) ? BUS_DMA_READ : 345 BUS_DMA_WRITE)); 346 } else 347 #endif /* TFS */ 348 { 349 error = bus_dmamap_load(dmat, 350 ccb->dmamap_xfer, xs->data, xs->datalen, 351 NULL, 352 ((flags & XS_CTL_NOSLEEP) ? BUS_DMA_NOWAIT : 353 BUS_DMA_WAITOK) | BUS_DMA_STREAMING | 354 ((flags & XS_CTL_DATA_IN) ? BUS_DMA_READ : 355 BUS_DMA_WRITE)); 356 } 357 358 switch (error) { 359 case 0: 360 break; 361 362 case ENOMEM: 363 case EAGAIN: 364 xs->error = XS_RESOURCE_SHORTAGE; 365 goto out_bad; 366 367 default: 368 xs->error = XS_DRIVER_STUFFUP; 369 printf("%s: error %d loading DMA map\n", 370 sc->sc_dev.dv_xname, error); 371 out_bad: 372 bha_free_ccb(sc, ccb); 373 scsipi_done(xs); 374 return; 375 } 376 377 bus_dmamap_sync(dmat, ccb->dmamap_xfer, 0, 378 ccb->dmamap_xfer->dm_mapsize, 379 (flags & XS_CTL_DATA_IN) ? BUS_DMASYNC_PREREAD : 380 BUS_DMASYNC_PREWRITE); 381 382 /* 383 * Load the hardware scatter/gather map with the 384 * contents of the DMA map. 385 */ 386 for (seg = 0; seg < ccb->dmamap_xfer->dm_nsegs; seg++) { 387 ltophys(ccb->dmamap_xfer->dm_segs[seg].ds_addr, 388 ccb->scat_gath[seg].seg_addr); 389 ltophys(ccb->dmamap_xfer->dm_segs[seg].ds_len, 390 ccb->scat_gath[seg].seg_len); 391 } 392 393 ltophys(ccb->hashkey + offsetof(struct bha_ccb, 394 scat_gath), ccb->data_addr); 395 ltophys(ccb->dmamap_xfer->dm_nsegs * 396 sizeof(struct bha_scat_gath), ccb->data_length); 397 } else { 398 /* 399 * No data xfer, use non S/G values. 400 */ 401 ltophys(0, ccb->data_addr); 402 ltophys(0, ccb->data_length); 403 } 404 405 if (XS_CTL_TAGTYPE(xs) != 0) { 406 ccb->tag_enable = 1; 407 ccb->tag_type = xs->xs_tag_type & 0x03; 408 } else { 409 ccb->tag_enable = 0; 410 ccb->tag_type = 0; 411 } 412 413 ccb->data_out = 0; 414 ccb->data_in = 0; 415 ccb->target = periph->periph_target; 416 ccb->lun = periph->periph_lun; 417 ltophys(ccb->hashkey + offsetof(struct bha_ccb, scsi_sense), 418 ccb->sense_ptr); 419 ccb->req_sense_length = sizeof(ccb->scsi_sense); 420 ccb->host_stat = 0x00; 421 ccb->target_stat = 0x00; 422 ccb->link_id = 0; 423 ltophys(0, ccb->link_addr); 424 425 BHA_CCB_SYNC(sc, ccb, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); 426 427 s = splbio(); 428 bha_queue_ccb(sc, ccb); 429 splx(s); 430 431 SC_DEBUG(periph, SCSIPI_DB3, ("cmd_sent\n")); 432 if ((flags & XS_CTL_POLL) == 0) 433 return; 434 435 /* 436 * If we can't use interrupts, poll on completion 437 */ 438 if (bha_poll(sc, xs, ccb->timeout)) { 439 bha_timeout(ccb); 440 if (bha_poll(sc, xs, ccb->timeout)) 441 bha_timeout(ccb); 442 } 443 return; 444 445 case ADAPTER_REQ_GROW_RESOURCES: 446 if (sc->sc_cur_ccbs == sc->sc_max_ccbs) { 447 chan->chan_flags &= ~SCSIPI_CHAN_CANGROW; 448 return; 449 } 450 seg = sc->sc_cur_ccbs; 451 bha_create_ccbs(sc, bha_ccbs_per_group); 452 adapt->adapt_openings += sc->sc_cur_ccbs - seg; 453 return; 454 455 case ADAPTER_REQ_SET_XFER_MODE: 456 /* 457 * Can't really do this on the Buslogic. It has its 458 * own setup info. But we do know how to query what 459 * the settings are. 460 */ 461 bha_get_xfer_mode(sc, (struct scsipi_xfer_mode *)arg); 462 return; 463 } 464 } 465 466 /* 467 * bha_minphys: 468 * 469 * Limit a transfer to our maximum transfer size. 470 */ 471 void 472 bha_minphys(struct buf *bp) 473 { 474 475 if (bp->b_bcount > BHA_MAXXFER) 476 bp->b_bcount = BHA_MAXXFER; 477 minphys(bp); 478 } 479 480 /***************************************************************************** 481 * SCSI job execution helper routines 482 *****************************************************************************/ 483 484 /* 485 * bha_get_xfer_mode; 486 * 487 * Negotiate the xfer mode for the specified periph, and report 488 * back the mode to the midlayer. 489 * 490 * NOTE: we must be called at splbio(). 491 */ 492 static void 493 bha_get_xfer_mode(struct bha_softc *sc, struct scsipi_xfer_mode *xm) 494 { 495 struct bha_setup hwsetup; 496 struct bha_period hwperiod; 497 struct bha_sync *bs; 498 int toff = xm->xm_target & 7, tmask = (1 << toff); 499 int wide, period, offset, rlen; 500 501 /* 502 * Issue an Inquire Setup Information. We can extract 503 * sync and wide information from here. 504 */ 505 rlen = sizeof(hwsetup.reply) + 506 ((sc->sc_flags & BHAF_WIDE) ? sizeof(hwsetup.reply_w) : 0); 507 hwsetup.cmd.opcode = BHA_INQUIRE_SETUP; 508 hwsetup.cmd.len = rlen; 509 bha_cmd(sc->sc_iot, sc->sc_ioh, sc->sc_dev.dv_xname, 510 sizeof(hwsetup.cmd), (u_char *)&hwsetup.cmd, 511 rlen, (u_char *)&hwsetup.reply); 512 513 xm->xm_mode = 0; 514 xm->xm_period = 0; 515 xm->xm_offset = 0; 516 517 /* 518 * First check for wide. On later boards, we can check 519 * directly in the setup info if wide is currently active. 520 * 521 * On earlier boards, we have to make an educated guess. 522 */ 523 if (sc->sc_flags & BHAF_WIDE) { 524 if (strcmp(sc->sc_firmware, "5.06L") >= 0) { 525 if (xm->xm_target > 7) { 526 wide = 527 hwsetup.reply_w.high_wide_active & tmask; 528 } else { 529 wide = 530 hwsetup.reply_w.low_wide_active & tmask; 531 } 532 if (wide) 533 xm->xm_mode |= PERIPH_CAP_WIDE16; 534 } else { 535 /* XXX Check `wide permitted' in the config info. */ 536 xm->xm_mode |= PERIPH_CAP_WIDE16; 537 } 538 } 539 540 /* 541 * Now get basic sync info. 542 */ 543 bs = (xm->xm_target > 7) ? 544 &hwsetup.reply_w.sync_high[toff] : 545 &hwsetup.reply.sync_low[toff]; 546 547 if (bs->valid) { 548 xm->xm_mode |= PERIPH_CAP_SYNC; 549 period = (bs->period * 50) + 20; 550 offset = bs->offset; 551 552 /* 553 * On boards that can do Fast and Ultra, use the Inquire Period 554 * command to get the period. 555 */ 556 if (sc->sc_firmware[0] >= '3') { 557 rlen = sizeof(hwperiod.reply) + 558 ((sc->sc_flags & BHAF_WIDE) ? 559 sizeof(hwperiod.reply_w) : 0); 560 hwperiod.cmd.opcode = BHA_INQUIRE_PERIOD; 561 hwperiod.cmd.len = rlen; 562 bha_cmd(sc->sc_iot, sc->sc_ioh, sc->sc_dev.dv_xname, 563 sizeof(hwperiod.cmd), (u_char *)&hwperiod.cmd, 564 rlen, (u_char *)&hwperiod.reply); 565 566 if (xm->xm_target > 7) 567 period = hwperiod.reply_w.period[toff]; 568 else 569 period = hwperiod.reply.period[toff]; 570 571 period *= 10; 572 } 573 574 xm->xm_period = 575 scsipi_sync_period_to_factor(period * 100); 576 xm->xm_offset = offset; 577 } 578 579 /* 580 * Now check for tagged queueing support. 581 * 582 * XXX Check `tags permitted' in the config info. 583 */ 584 if (sc->sc_flags & BHAF_TAGGED_QUEUEING) 585 xm->xm_mode |= PERIPH_CAP_TQING; 586 587 scsipi_async_event(&sc->sc_channel, ASYNC_EVENT_XFER_MODE, xm); 588 } 589 590 /* 591 * bha_done: 592 * 593 * A CCB has completed execution. Pass the status back to the 594 * upper layer. 595 */ 596 static void 597 bha_done(struct bha_softc *sc, struct bha_ccb *ccb) 598 { 599 bus_dma_tag_t dmat = sc->sc_dmat; 600 struct scsipi_xfer *xs = ccb->xs; 601 602 SC_DEBUG(xs->xs_periph, SCSIPI_DB2, ("bha_done\n")); 603 604 #ifdef BHADIAG 605 if (ccb->flags & CCB_SENDING) { 606 printf("%s: exiting ccb still in transit!\n", 607 sc->sc_dev.dv_xname); 608 Debugger(); 609 return; 610 } 611 #endif 612 if ((ccb->flags & CCB_ALLOC) == 0) { 613 printf("%s: exiting ccb not allocated!\n", 614 sc->sc_dev.dv_xname); 615 Debugger(); 616 return; 617 } 618 619 /* 620 * If we were a data transfer, unload the map that described 621 * the data buffer. 622 */ 623 if (xs->datalen) { 624 bus_dmamap_sync(dmat, ccb->dmamap_xfer, 0, 625 ccb->dmamap_xfer->dm_mapsize, 626 (xs->xs_control & XS_CTL_DATA_IN) ? BUS_DMASYNC_POSTREAD : 627 BUS_DMASYNC_POSTWRITE); 628 bus_dmamap_unload(dmat, ccb->dmamap_xfer); 629 } 630 631 if (xs->error == XS_NOERROR) { 632 if (ccb->host_stat != BHA_OK) { 633 switch (ccb->host_stat) { 634 case BHA_SEL_TIMEOUT: /* No response */ 635 xs->error = XS_SELTIMEOUT; 636 break; 637 default: /* Other scsi protocol messes */ 638 printf("%s: host_stat %x\n", 639 sc->sc_dev.dv_xname, ccb->host_stat); 640 xs->error = XS_DRIVER_STUFFUP; 641 break; 642 } 643 } else if (ccb->target_stat != SCSI_OK) { 644 switch (ccb->target_stat) { 645 case SCSI_CHECK: 646 memcpy(&xs->sense.scsi_sense, 647 &ccb->scsi_sense, 648 sizeof(xs->sense.scsi_sense)); 649 xs->error = XS_SENSE; 650 break; 651 case SCSI_BUSY: 652 xs->error = XS_BUSY; 653 break; 654 default: 655 printf("%s: target_stat %x\n", 656 sc->sc_dev.dv_xname, ccb->target_stat); 657 xs->error = XS_DRIVER_STUFFUP; 658 break; 659 } 660 } else 661 xs->resid = 0; 662 } 663 664 bha_free_ccb(sc, ccb); 665 scsipi_done(xs); 666 } 667 668 /* 669 * bha_poll: 670 * 671 * Poll for completion of the specified job. 672 */ 673 static int 674 bha_poll(struct bha_softc *sc, struct scsipi_xfer *xs, int count) 675 { 676 bus_space_tag_t iot = sc->sc_iot; 677 bus_space_handle_t ioh = sc->sc_ioh; 678 679 /* timeouts are in msec, so we loop in 1000 usec cycles */ 680 while (count) { 681 /* 682 * If we had interrupts enabled, would we 683 * have got an interrupt? 684 */ 685 if (bus_space_read_1(iot, ioh, BHA_INTR_PORT) & 686 BHA_INTR_ANYINTR) 687 bha_intr(sc); 688 if (xs->xs_status & XS_STS_DONE) 689 return (0); 690 delay(1000); /* only happens in boot so ok */ 691 count--; 692 } 693 return (1); 694 } 695 696 /* 697 * bha_timeout: 698 * 699 * CCB timeout handler. 700 */ 701 static void 702 bha_timeout(void *arg) 703 { 704 struct bha_ccb *ccb = arg; 705 struct scsipi_xfer *xs = ccb->xs; 706 struct scsipi_periph *periph = xs->xs_periph; 707 struct bha_softc *sc = 708 (void *)periph->periph_channel->chan_adapter->adapt_dev; 709 int s; 710 711 scsipi_printaddr(periph); 712 printf("timed out"); 713 714 s = splbio(); 715 716 #ifdef BHADIAG 717 /* 718 * If the ccb's mbx is not free, then the board has gone Far East? 719 */ 720 bha_collect_mbo(sc); 721 if (ccb->flags & CCB_SENDING) { 722 printf("%s: not taking commands!\n", sc->sc_dev.dv_xname); 723 Debugger(); 724 } 725 #endif 726 727 /* 728 * If it has been through before, then 729 * a previous abort has failed, don't 730 * try abort again 731 */ 732 if (ccb->flags & CCB_ABORT) { 733 /* abort timed out */ 734 printf(" AGAIN\n"); 735 /* XXX Must reset! */ 736 } else { 737 /* abort the operation that has timed out */ 738 printf("\n"); 739 ccb->xs->error = XS_TIMEOUT; 740 ccb->timeout = BHA_ABORT_TIMEOUT; 741 ccb->flags |= CCB_ABORT; 742 bha_queue_ccb(sc, ccb); 743 } 744 745 splx(s); 746 } 747 748 /***************************************************************************** 749 * Misc. subroutines. 750 *****************************************************************************/ 751 752 /* 753 * bha_cmd: 754 * 755 * Send a command to the Buglogic controller. 756 */ 757 static int 758 bha_cmd(bus_space_tag_t iot, bus_space_handle_t ioh, const char *name, int icnt, 759 u_char *ibuf, int ocnt, u_char *obuf) 760 { 761 int i; 762 int wait; 763 u_char sts; 764 u_char opcode = ibuf[0]; 765 766 /* 767 * Calculate a reasonable timeout for the command. 768 */ 769 switch (opcode) { 770 case BHA_INQUIRE_DEVICES: 771 case BHA_INQUIRE_DEVICES_2: 772 wait = 90 * 20000; 773 break; 774 default: 775 wait = 1 * 20000; 776 break; 777 } 778 779 /* 780 * Wait for the adapter to go idle, unless it's one of 781 * the commands which don't need this 782 */ 783 if (opcode != BHA_MBO_INTR_EN) { 784 for (i = 20000; i; i--) { /* 1 sec? */ 785 sts = bus_space_read_1(iot, ioh, BHA_STAT_PORT); 786 if (sts & BHA_STAT_IDLE) 787 break; 788 delay(50); 789 } 790 if (!i) { 791 printf("%s: bha_cmd, host not idle(0x%x)\n", 792 name, sts); 793 return (1); 794 } 795 } 796 797 /* 798 * Now that it is idle, if we expect output, preflush the 799 * queue feeding to us. 800 */ 801 if (ocnt) { 802 while ((bus_space_read_1(iot, ioh, BHA_STAT_PORT)) & 803 BHA_STAT_DF) 804 bus_space_read_1(iot, ioh, BHA_DATA_PORT); 805 } 806 807 /* 808 * Output the command and the number of arguments given 809 * for each byte, first check the port is empty. 810 */ 811 while (icnt--) { 812 for (i = wait; i; i--) { 813 sts = bus_space_read_1(iot, ioh, BHA_STAT_PORT); 814 if (!(sts & BHA_STAT_CDF)) 815 break; 816 delay(50); 817 } 818 if (!i) { 819 if (opcode != BHA_INQUIRE_REVISION) 820 printf("%s: bha_cmd, cmd/data port full\n", 821 name); 822 goto bad; 823 } 824 bus_space_write_1(iot, ioh, BHA_CMD_PORT, *ibuf++); 825 } 826 827 /* 828 * If we expect input, loop that many times, each time, 829 * looking for the data register to have valid data 830 */ 831 while (ocnt--) { 832 for (i = wait; i; i--) { 833 sts = bus_space_read_1(iot, ioh, BHA_STAT_PORT); 834 if (sts & BHA_STAT_DF) 835 break; 836 delay(50); 837 } 838 if (!i) { 839 #ifdef BHADEBUG 840 if (opcode != BHA_INQUIRE_REVISION) 841 printf("%s: bha_cmd, cmd/data port empty %d\n", 842 name, ocnt); 843 #endif /* BHADEBUG */ 844 goto bad; 845 } 846 *obuf++ = bus_space_read_1(iot, ioh, BHA_DATA_PORT); 847 } 848 849 /* 850 * Wait for the board to report a finished instruction. 851 * We may get an extra interrupt for the HACC signal, but this is 852 * unimportant. 853 */ 854 if (opcode != BHA_MBO_INTR_EN && opcode != BHA_MODIFY_IOPORT) { 855 for (i = 20000; i; i--) { /* 1 sec? */ 856 sts = bus_space_read_1(iot, ioh, BHA_INTR_PORT); 857 /* XXX Need to save this in the interrupt handler? */ 858 if (sts & BHA_INTR_HACC) 859 break; 860 delay(50); 861 } 862 if (!i) { 863 printf("%s: bha_cmd, host not finished(0x%x)\n", 864 name, sts); 865 return (1); 866 } 867 } 868 bus_space_write_1(iot, ioh, BHA_CTRL_PORT, BHA_CTRL_IRST); 869 return (0); 870 871 bad: 872 bus_space_write_1(iot, ioh, BHA_CTRL_PORT, BHA_CTRL_SRST); 873 return (1); 874 } 875 876 /* 877 * bha_find: 878 * 879 * Find the board. 880 */ 881 int 882 bha_find(bus_space_tag_t iot, bus_space_handle_t ioh) 883 { 884 int i; 885 u_char sts; 886 struct bha_extended_inquire inquire; 887 888 /* Check something is at the ports we need to access */ 889 sts = bus_space_read_1(iot, ioh, BHA_STAT_PORT); 890 if (sts == 0xFF) 891 return (0); 892 893 /* 894 * Reset board, If it doesn't respond, assume 895 * that it's not there.. good for the probe 896 */ 897 898 bus_space_write_1(iot, ioh, BHA_CTRL_PORT, 899 BHA_CTRL_HRST | BHA_CTRL_SRST); 900 901 delay(100); 902 for (i = BHA_RESET_TIMEOUT; i; i--) { 903 sts = bus_space_read_1(iot, ioh, BHA_STAT_PORT); 904 if (sts == (BHA_STAT_IDLE | BHA_STAT_INIT)) 905 break; 906 delay(1000); 907 } 908 if (!i) { 909 #ifdef BHADEBUG 910 if (bha_debug) 911 printf("bha_find: No answer from buslogic board\n"); 912 #endif /* BHADEBUG */ 913 return (0); 914 } 915 916 /* 917 * The BusLogic cards implement an Adaptec 1542 (aha)-compatible 918 * interface. The native bha interface is not compatible with 919 * an aha. 1542. We need to ensure that we never match an 920 * Adaptec 1542. We must also avoid sending Adaptec-compatible 921 * commands to a real bha, lest it go into 1542 emulation mode. 922 * (On an indirect bus like ISA, we should always probe for BusLogic 923 * interfaces before Adaptec interfaces). 924 */ 925 926 /* 927 * Make sure we don't match an AHA-1542A or AHA-1542B, by checking 928 * for an extended-geometry register. The 1542[AB] don't have one. 929 */ 930 sts = bus_space_read_1(iot, ioh, BHA_EXTGEOM_PORT); 931 if (sts == 0xFF) 932 return (0); 933 934 /* 935 * Check that we actually know how to use this board. 936 */ 937 delay(1000); 938 inquire.cmd.opcode = BHA_INQUIRE_EXTENDED; 939 inquire.cmd.len = sizeof(inquire.reply); 940 i = bha_cmd(iot, ioh, "(bha_find)", 941 sizeof(inquire.cmd), (u_char *)&inquire.cmd, 942 sizeof(inquire.reply), (u_char *)&inquire.reply); 943 944 /* 945 * Some 1542Cs (CP, perhaps not CF, may depend on firmware rev) 946 * have the extended-geometry register and also respond to 947 * BHA_INQUIRE_EXTENDED. Make sure we never match such cards, 948 * by checking the size of the reply is what a BusLogic card returns. 949 */ 950 if (i) { 951 #ifdef BHADEBUG 952 printf("bha_find: board returned %d instead of %d to %s\n", 953 i, sizeof(inquire.reply), "INQUIRE_EXTENDED"); 954 #endif 955 return (0); 956 } 957 958 /* OK, we know we've found a buslogic adaptor. */ 959 960 switch (inquire.reply.bus_type) { 961 case BHA_BUS_TYPE_24BIT: 962 case BHA_BUS_TYPE_32BIT: 963 break; 964 case BHA_BUS_TYPE_MCA: 965 /* We don't grok MicroChannel (yet). */ 966 return (0); 967 default: 968 printf("bha_find: illegal bus type %c\n", 969 inquire.reply.bus_type); 970 return (0); 971 } 972 973 return (1); 974 } 975 976 977 /* 978 * bha_inquire_config: 979 * 980 * Determine irq/drq. 981 */ 982 int 983 bha_inquire_config(bus_space_tag_t iot, bus_space_handle_t ioh, 984 struct bha_probe_data *sc) 985 { 986 int irq, drq; 987 struct bha_config config; 988 989 /* 990 * Assume we have a board at this stage setup DMA channel from 991 * jumpers and save int level 992 */ 993 delay(1000); 994 config.cmd.opcode = BHA_INQUIRE_CONFIG; 995 bha_cmd(iot, ioh, "(bha_inquire_config)", 996 sizeof(config.cmd), (u_char *)&config.cmd, 997 sizeof(config.reply), (u_char *)&config.reply); 998 switch (config.reply.chan) { 999 case EISADMA: 1000 drq = -1; 1001 break; 1002 case CHAN0: 1003 drq = 0; 1004 break; 1005 case CHAN5: 1006 drq = 5; 1007 break; 1008 case CHAN6: 1009 drq = 6; 1010 break; 1011 case CHAN7: 1012 drq = 7; 1013 break; 1014 default: 1015 printf("bha: illegal drq setting %x\n", 1016 config.reply.chan); 1017 return (0); 1018 } 1019 1020 switch (config.reply.intr) { 1021 case INT9: 1022 irq = 9; 1023 break; 1024 case INT10: 1025 irq = 10; 1026 break; 1027 case INT11: 1028 irq = 11; 1029 break; 1030 case INT12: 1031 irq = 12; 1032 break; 1033 case INT14: 1034 irq = 14; 1035 break; 1036 case INT15: 1037 irq = 15; 1038 break; 1039 default: 1040 printf("bha: illegal irq setting %x\n", 1041 config.reply.intr); 1042 return (0); 1043 } 1044 1045 /* if we want to fill in softc, do so now */ 1046 if (sc != NULL) { 1047 sc->sc_irq = irq; 1048 sc->sc_drq = drq; 1049 } 1050 1051 return (1); 1052 } 1053 1054 int 1055 bha_probe_inquiry(bus_space_tag_t iot, bus_space_handle_t ioh, 1056 struct bha_probe_data *bpd) 1057 { 1058 return bha_find(iot, ioh) && bha_inquire_config(iot, ioh, bpd); 1059 } 1060 1061 /* 1062 * bha_disable_isacompat: 1063 * 1064 * Disable the ISA-compatibility ioports on PCI bha devices, 1065 * to ensure they're not autoconfigured a second time as an ISA bha. 1066 */ 1067 int 1068 bha_disable_isacompat(struct bha_softc *sc) 1069 { 1070 struct bha_isadisable isa_disable; 1071 1072 isa_disable.cmd.opcode = BHA_MODIFY_IOPORT; 1073 isa_disable.cmd.modifier = BHA_IOMODIFY_DISABLE1; 1074 bha_cmd(sc->sc_iot, sc->sc_ioh, sc->sc_dev.dv_xname, 1075 sizeof(isa_disable.cmd), (u_char*)&isa_disable.cmd, 1076 0, (u_char *)0); 1077 return (0); 1078 } 1079 1080 /* 1081 * bha_info: 1082 * 1083 * Get information about the board, and report it. We 1084 * return the initial number of CCBs, 0 if we failed. 1085 */ 1086 int 1087 bha_info(struct bha_softc *sc) 1088 { 1089 bus_space_tag_t iot = sc->sc_iot; 1090 bus_space_handle_t ioh = sc->sc_ioh; 1091 struct bha_extended_inquire inquire; 1092 struct bha_config config; 1093 struct bha_devices devices; 1094 struct bha_setup setup; 1095 struct bha_model model; 1096 struct bha_revision revision; 1097 struct bha_digit digit; 1098 int i, j, initial_ccbs, rlen; 1099 char *name = sc->sc_dev.dv_xname; 1100 char *p; 1101 1102 /* 1103 * Fetch the extended inquire information. 1104 */ 1105 inquire.cmd.opcode = BHA_INQUIRE_EXTENDED; 1106 inquire.cmd.len = sizeof(inquire.reply); 1107 bha_cmd(iot, ioh, name, 1108 sizeof(inquire.cmd), (u_char *)&inquire.cmd, 1109 sizeof(inquire.reply), (u_char *)&inquire.reply); 1110 1111 /* 1112 * Fetch the configuration information. 1113 */ 1114 config.cmd.opcode = BHA_INQUIRE_CONFIG; 1115 bha_cmd(iot, ioh, name, 1116 sizeof(config.cmd), (u_char *)&config.cmd, 1117 sizeof(config.reply), (u_char *)&config.reply); 1118 1119 sc->sc_scsi_id = config.reply.scsi_dev; 1120 1121 /* 1122 * Get the firmware revision. 1123 */ 1124 p = sc->sc_firmware; 1125 revision.cmd.opcode = BHA_INQUIRE_REVISION; 1126 bha_cmd(iot, ioh, name, 1127 sizeof(revision.cmd), (u_char *)&revision.cmd, 1128 sizeof(revision.reply), (u_char *)&revision.reply); 1129 *p++ = revision.reply.firm_revision; 1130 *p++ = '.'; 1131 *p++ = revision.reply.firm_version; 1132 digit.cmd.opcode = BHA_INQUIRE_REVISION_3; 1133 bha_cmd(iot, ioh, name, 1134 sizeof(digit.cmd), (u_char *)&digit.cmd, 1135 sizeof(digit.reply), (u_char *)&digit.reply); 1136 *p++ = digit.reply.digit; 1137 if (revision.reply.firm_revision >= '3' || 1138 (revision.reply.firm_revision == '3' && 1139 revision.reply.firm_version >= '3')) { 1140 digit.cmd.opcode = BHA_INQUIRE_REVISION_4; 1141 bha_cmd(iot, ioh, name, 1142 sizeof(digit.cmd), (u_char *)&digit.cmd, 1143 sizeof(digit.reply), (u_char *)&digit.reply); 1144 *p++ = digit.reply.digit; 1145 } 1146 while (p > sc->sc_firmware && (p[-1] == ' ' || p[-1] == '\0')) 1147 p--; 1148 *p = '\0'; 1149 1150 /* 1151 * Get the model number. 1152 * 1153 * Some boards do not handle the Inquire Board Model Number 1154 * command correctly, or don't give correct information. 1155 * 1156 * So, we use the Firmware Revision and Extended Setup 1157 * information to fixup the model number in these cases. 1158 * 1159 * The firmware version indicates: 1160 * 1161 * 5.xx BusLogic "W" Series Host Adapters 1162 * BT-948/958/958D 1163 * 1164 * 4.xx BusLogic "C" Series Host Adapters 1165 * BT-946C/956C/956CD/747C/757C/757CD/445C/545C/540CF 1166 * 1167 * 3.xx BusLogic "S" Series Host Adapters 1168 * BT-747S/747D/757S/757D/445S/545S/542D 1169 * BT-542B/742A (revision H) 1170 * 1171 * 2.xx BusLogic "A" Series Host Adapters 1172 * BT-542B/742A (revision G and below) 1173 * 1174 * 0.xx AMI FastDisk VLB/EISA BusLogic Clone Host Adapter 1175 */ 1176 if (inquire.reply.bus_type == BHA_BUS_TYPE_24BIT && 1177 sc->sc_firmware[0] < '3') 1178 snprintf(sc->sc_model, sizeof(sc->sc_model), "542B"); 1179 else if (inquire.reply.bus_type == BHA_BUS_TYPE_32BIT && 1180 sc->sc_firmware[0] == '2' && 1181 (sc->sc_firmware[2] == '1' || 1182 (sc->sc_firmware[2] == '2' && sc->sc_firmware[3] == '0'))) 1183 snprintf(sc->sc_model, sizeof(sc->sc_model), "742A"); 1184 else if (inquire.reply.bus_type == BHA_BUS_TYPE_32BIT && 1185 sc->sc_firmware[0] == '0') 1186 snprintf(sc->sc_model, sizeof(sc->sc_model), "747A"); 1187 else { 1188 p = sc->sc_model; 1189 model.cmd.opcode = BHA_INQUIRE_MODEL; 1190 model.cmd.len = sizeof(model.reply); 1191 bha_cmd(iot, ioh, name, 1192 sizeof(model.cmd), (u_char *)&model.cmd, 1193 sizeof(model.reply), (u_char *)&model.reply); 1194 *p++ = model.reply.id[0]; 1195 *p++ = model.reply.id[1]; 1196 *p++ = model.reply.id[2]; 1197 *p++ = model.reply.id[3]; 1198 while (p > sc->sc_model && (p[-1] == ' ' || p[-1] == '\0')) 1199 p--; 1200 *p++ = model.reply.version[0]; 1201 *p++ = model.reply.version[1]; 1202 while (p > sc->sc_model && (p[-1] == ' ' || p[-1] == '\0')) 1203 p--; 1204 *p = '\0'; 1205 } 1206 1207 /* Enable round-robin scheme - appeared at firmware rev. 3.31. */ 1208 if (strcmp(sc->sc_firmware, "3.31") >= 0) 1209 sc->sc_flags |= BHAF_STRICT_ROUND_ROBIN; 1210 1211 /* 1212 * Determine some characteristics about our bus. 1213 */ 1214 if (inquire.reply.scsi_flags & BHA_SCSI_WIDE) 1215 sc->sc_flags |= BHAF_WIDE; 1216 if (inquire.reply.scsi_flags & BHA_SCSI_DIFFERENTIAL) 1217 sc->sc_flags |= BHAF_DIFFERENTIAL; 1218 if (inquire.reply.scsi_flags & BHA_SCSI_ULTRA) 1219 sc->sc_flags |= BHAF_ULTRA; 1220 1221 /* 1222 * Determine some characterists of the board. 1223 */ 1224 sc->sc_max_dmaseg = inquire.reply.sg_limit; 1225 1226 /* 1227 * Determine the maximum CCB count and whether or not 1228 * tagged queueing is available on this host adapter. 1229 * 1230 * Tagged queueing works on: 1231 * 1232 * "W" Series adapters 1233 * "C" Series adapters with firmware >= 4.22 1234 * "S" Series adapters with firmware >= 3.35 1235 * 1236 * The internal CCB counts are: 1237 * 1238 * 192 BT-948/958/958D 1239 * 100 BT-946C/956C/956CD/747C/757C/757CD/445C 1240 * 50 BT-545C/540CF 1241 * 30 BT-747S/747D/757S/757D/445S/545S/542D/542B/742A 1242 */ 1243 switch (sc->sc_firmware[0]) { 1244 case '5': 1245 sc->sc_max_ccbs = 192; 1246 sc->sc_flags |= BHAF_TAGGED_QUEUEING; 1247 break; 1248 1249 case '4': 1250 if (sc->sc_model[0] == '5') 1251 sc->sc_max_ccbs = 50; 1252 else 1253 sc->sc_max_ccbs = 100; 1254 if (strcmp(sc->sc_firmware, "4.22") >= 0) 1255 sc->sc_flags |= BHAF_TAGGED_QUEUEING; 1256 break; 1257 1258 case '3': 1259 if (strcmp(sc->sc_firmware, "3.35") >= 0) 1260 sc->sc_flags |= BHAF_TAGGED_QUEUEING; 1261 /* FALLTHROUGH */ 1262 1263 default: 1264 sc->sc_max_ccbs = 30; 1265 } 1266 1267 /* 1268 * Set the mailbox count to precisely the number of HW CCBs 1269 * available. A mailbox isn't required while a CCB is executing, 1270 * but this allows us to actually enqueue up to our resource 1271 * limit. 1272 * 1273 * This will keep the mailbox count small on boards which don't 1274 * have strict round-robin (they have to scan the entire set of 1275 * mailboxes each time they run a command). 1276 */ 1277 sc->sc_mbox_count = sc->sc_max_ccbs; 1278 1279 /* 1280 * Obtain setup information. 1281 */ 1282 rlen = sizeof(setup.reply) + 1283 ((sc->sc_flags & BHAF_WIDE) ? sizeof(setup.reply_w) : 0); 1284 setup.cmd.opcode = BHA_INQUIRE_SETUP; 1285 setup.cmd.len = rlen; 1286 bha_cmd(iot, ioh, name, 1287 sizeof(setup.cmd), (u_char *)&setup.cmd, 1288 rlen, (u_char *)&setup.reply); 1289 1290 aprint_normal("%s: model BT-%s, firmware %s\n", sc->sc_dev.dv_xname, 1291 sc->sc_model, sc->sc_firmware); 1292 1293 aprint_normal("%s: %d H/W CCBs", sc->sc_dev.dv_xname, sc->sc_max_ccbs); 1294 if (setup.reply.sync_neg) 1295 aprint_normal(", sync"); 1296 if (setup.reply.parity) 1297 aprint_normal(", parity"); 1298 if (sc->sc_flags & BHAF_TAGGED_QUEUEING) 1299 aprint_normal(", tagged queueing"); 1300 if (sc->sc_flags & BHAF_WIDE_LUN) 1301 aprint_normal(", wide LUN support"); 1302 aprint_normal("\n"); 1303 1304 /* 1305 * Poll targets 0 - 7. 1306 */ 1307 devices.cmd.opcode = BHA_INQUIRE_DEVICES; 1308 bha_cmd(iot, ioh, name, 1309 sizeof(devices.cmd), (u_char *)&devices.cmd, 1310 sizeof(devices.reply), (u_char *)&devices.reply); 1311 1312 /* Count installed units. */ 1313 initial_ccbs = 0; 1314 for (i = 0; i < 8; i++) { 1315 for (j = 0; j < 8; j++) { 1316 if (((devices.reply.lun_map[i] >> j) & 1) == 1) 1317 initial_ccbs++; 1318 } 1319 } 1320 1321 /* 1322 * Poll targets 8 - 15 if we have a wide bus. 1323 */ 1324 if (sc->sc_flags & BHAF_WIDE) { 1325 devices.cmd.opcode = BHA_INQUIRE_DEVICES_2; 1326 bha_cmd(iot, ioh, name, 1327 sizeof(devices.cmd), (u_char *)&devices.cmd, 1328 sizeof(devices.reply), (u_char *)&devices.reply); 1329 1330 for (i = 0; i < 8; i++) { 1331 for (j = 0; j < 8; j++) { 1332 if (((devices.reply.lun_map[i] >> j) & 1) == 1) 1333 initial_ccbs++; 1334 } 1335 } 1336 } 1337 1338 /* 1339 * Double the initial CCB count, for good measure. 1340 */ 1341 initial_ccbs *= 2; 1342 1343 /* 1344 * Sanity check the initial CCB count; don't create more than 1345 * we can enqueue (sc_max_ccbs), and make sure there are some 1346 * at all. 1347 */ 1348 if (initial_ccbs > sc->sc_max_ccbs) 1349 initial_ccbs = sc->sc_max_ccbs; 1350 if (initial_ccbs == 0) 1351 initial_ccbs = 2; 1352 1353 return (initial_ccbs); 1354 } 1355 1356 /* 1357 * bha_init: 1358 * 1359 * Initialize the board. 1360 */ 1361 static int 1362 bha_init(struct bha_softc *sc) 1363 { 1364 char *name = sc->sc_dev.dv_xname; 1365 struct bha_toggle toggle; 1366 struct bha_mailbox mailbox; 1367 struct bha_mbx_out *mbo; 1368 struct bha_mbx_in *mbi; 1369 int i; 1370 1371 /* 1372 * Set up the mailbox. We always run the mailbox in round-robin. 1373 */ 1374 for (i = 0; i < sc->sc_mbox_count; i++) { 1375 mbo = &sc->sc_mbo[i]; 1376 mbi = &sc->sc_mbi[i]; 1377 1378 mbo->cmd = BHA_MBO_FREE; 1379 BHA_MBO_SYNC(sc, mbo, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); 1380 1381 mbi->comp_stat = BHA_MBI_FREE; 1382 BHA_MBI_SYNC(sc, mbi, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); 1383 } 1384 1385 sc->sc_cmbo = sc->sc_tmbo = &sc->sc_mbo[0]; 1386 sc->sc_tmbi = &sc->sc_mbi[0]; 1387 1388 sc->sc_mbofull = 0; 1389 1390 /* 1391 * If the board supports strict round-robin, enable that. 1392 */ 1393 if (sc->sc_flags & BHAF_STRICT_ROUND_ROBIN) { 1394 toggle.cmd.opcode = BHA_ROUND_ROBIN; 1395 toggle.cmd.enable = 1; 1396 bha_cmd(sc->sc_iot, sc->sc_ioh, name, 1397 sizeof(toggle.cmd), (u_char *)&toggle.cmd, 1398 0, NULL); 1399 } 1400 1401 /* 1402 * Give the mailbox to the board. 1403 */ 1404 mailbox.cmd.opcode = BHA_MBX_INIT_EXTENDED; 1405 mailbox.cmd.nmbx = sc->sc_mbox_count; 1406 ltophys(sc->sc_dmamap_mbox->dm_segs[0].ds_addr, mailbox.cmd.addr); 1407 bha_cmd(sc->sc_iot, sc->sc_ioh, name, 1408 sizeof(mailbox.cmd), (u_char *)&mailbox.cmd, 1409 0, (u_char *)0); 1410 1411 return (0); 1412 } 1413 1414 /***************************************************************************** 1415 * CCB execution engine 1416 *****************************************************************************/ 1417 1418 /* 1419 * bha_queue_ccb: 1420 * 1421 * Queue a CCB to be sent to the controller, and send it if possible. 1422 */ 1423 static void 1424 bha_queue_ccb(struct bha_softc *sc, struct bha_ccb *ccb) 1425 { 1426 1427 TAILQ_INSERT_TAIL(&sc->sc_waiting_ccb, ccb, chain); 1428 bha_start_ccbs(sc); 1429 } 1430 1431 /* 1432 * bha_start_ccbs: 1433 * 1434 * Send as many CCBs as we have empty mailboxes for. 1435 */ 1436 static void 1437 bha_start_ccbs(struct bha_softc *sc) 1438 { 1439 bus_space_tag_t iot = sc->sc_iot; 1440 bus_space_handle_t ioh = sc->sc_ioh; 1441 struct bha_ccb_group *bcg; 1442 struct bha_mbx_out *mbo; 1443 struct bha_ccb *ccb; 1444 1445 mbo = sc->sc_tmbo; 1446 1447 while ((ccb = TAILQ_FIRST(&sc->sc_waiting_ccb)) != NULL) { 1448 if (sc->sc_mbofull >= sc->sc_mbox_count) { 1449 #ifdef DIAGNOSTIC 1450 if (sc->sc_mbofull > sc->sc_mbox_count) 1451 panic("bha_start_ccbs: mbofull > mbox_count"); 1452 #endif 1453 /* 1454 * No mailboxes available; attempt to collect ones 1455 * that have already been used. 1456 */ 1457 bha_collect_mbo(sc); 1458 if (sc->sc_mbofull == sc->sc_mbox_count) { 1459 /* 1460 * Still no more available; have the 1461 * controller interrupt us when it 1462 * frees one. 1463 */ 1464 struct bha_toggle toggle; 1465 1466 toggle.cmd.opcode = BHA_MBO_INTR_EN; 1467 toggle.cmd.enable = 1; 1468 bha_cmd(iot, ioh, sc->sc_dev.dv_xname, 1469 sizeof(toggle.cmd), (u_char *)&toggle.cmd, 1470 0, (u_char *)0); 1471 break; 1472 } 1473 } 1474 1475 TAILQ_REMOVE(&sc->sc_waiting_ccb, ccb, chain); 1476 #ifdef BHADIAG 1477 ccb->flags |= CCB_SENDING; 1478 #endif 1479 1480 /* 1481 * Put the CCB in the mailbox. 1482 */ 1483 bcg = BHA_CCB_GROUP(ccb); 1484 ltophys(bcg->bcg_dmamap->dm_segs[0].ds_addr + 1485 BHA_CCB_OFFSET(ccb), mbo->ccb_addr); 1486 if (ccb->flags & CCB_ABORT) 1487 mbo->cmd = BHA_MBO_ABORT; 1488 else 1489 mbo->cmd = BHA_MBO_START; 1490 1491 BHA_MBO_SYNC(sc, mbo, 1492 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); 1493 1494 /* Tell the card to poll immediately. */ 1495 bus_space_write_1(iot, ioh, BHA_CMD_PORT, BHA_START_SCSI); 1496 1497 if ((ccb->xs->xs_control & XS_CTL_POLL) == 0) 1498 callout_reset(&ccb->xs->xs_callout, 1499 mstohz(ccb->timeout), bha_timeout, ccb); 1500 1501 ++sc->sc_mbofull; 1502 mbo = bha_nextmbo(sc, mbo); 1503 } 1504 1505 sc->sc_tmbo = mbo; 1506 } 1507 1508 /* 1509 * bha_finish_ccbs: 1510 * 1511 * Finalize the execution of CCBs in our incoming mailbox. 1512 */ 1513 static void 1514 bha_finish_ccbs(struct bha_softc *sc) 1515 { 1516 struct bha_mbx_in *mbi; 1517 struct bha_ccb *ccb; 1518 int i; 1519 1520 mbi = sc->sc_tmbi; 1521 1522 BHA_MBI_SYNC(sc, mbi, BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); 1523 1524 if (mbi->comp_stat == BHA_MBI_FREE) { 1525 for (i = 0; i < sc->sc_mbox_count; i++) { 1526 if (mbi->comp_stat != BHA_MBI_FREE) { 1527 #ifdef BHADIAG 1528 /* 1529 * This can happen in normal operation if 1530 * we use all mailbox slots. 1531 */ 1532 printf("%s: mbi not in round-robin order\n", 1533 sc->sc_dev.dv_xname); 1534 #endif 1535 goto again; 1536 } 1537 mbi = bha_nextmbi(sc, mbi); 1538 BHA_MBI_SYNC(sc, mbi, 1539 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); 1540 } 1541 #ifdef BHADIAGnot 1542 printf("%s: mbi interrupt with no full mailboxes\n", 1543 sc->sc_dev.dv_xname); 1544 #endif 1545 return; 1546 } 1547 1548 again: 1549 do { 1550 ccb = bha_ccb_phys_kv(sc, phystol(mbi->ccb_addr)); 1551 if (ccb == NULL) { 1552 printf("%s: bad mbi ccb pointer 0x%08x; skipping\n", 1553 sc->sc_dev.dv_xname, phystol(mbi->ccb_addr)); 1554 goto next; 1555 } 1556 1557 BHA_CCB_SYNC(sc, ccb, 1558 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); 1559 1560 #ifdef BHADEBUG 1561 if (bha_debug) { 1562 u_char *cp = &ccb->scsi_cmd; 1563 printf("op=%x %x %x %x %x %x\n", 1564 cp[0], cp[1], cp[2], cp[3], cp[4], cp[5]); 1565 printf("comp_stat %x for mbi addr = %p, ", 1566 mbi->comp_stat, mbi); 1567 printf("ccb addr = %p\n", ccb); 1568 } 1569 #endif /* BHADEBUG */ 1570 1571 switch (mbi->comp_stat) { 1572 case BHA_MBI_OK: 1573 case BHA_MBI_ERROR: 1574 if ((ccb->flags & CCB_ABORT) != 0) { 1575 /* 1576 * If we already started an abort, wait for it 1577 * to complete before clearing the CCB. We 1578 * could instead just clear CCB_SENDING, but 1579 * what if the mailbox was already received? 1580 * The worst that happens here is that we clear 1581 * the CCB a bit later than we need to. BFD. 1582 */ 1583 goto next; 1584 } 1585 break; 1586 1587 case BHA_MBI_ABORT: 1588 case BHA_MBI_UNKNOWN: 1589 /* 1590 * Even if the CCB wasn't found, we clear it anyway. 1591 * See preceding comment. 1592 */ 1593 break; 1594 1595 default: 1596 printf("%s: bad mbi comp_stat %02x; skipping\n", 1597 sc->sc_dev.dv_xname, mbi->comp_stat); 1598 goto next; 1599 } 1600 1601 callout_stop(&ccb->xs->xs_callout); 1602 bha_done(sc, ccb); 1603 1604 next: 1605 mbi->comp_stat = BHA_MBI_FREE; 1606 BHA_CCB_SYNC(sc, ccb, 1607 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); 1608 1609 mbi = bha_nextmbi(sc, mbi); 1610 BHA_MBI_SYNC(sc, mbi, 1611 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); 1612 } while (mbi->comp_stat != BHA_MBI_FREE); 1613 1614 sc->sc_tmbi = mbi; 1615 } 1616 1617 /***************************************************************************** 1618 * Mailbox management functions. 1619 *****************************************************************************/ 1620 1621 /* 1622 * bha_create_mailbox: 1623 * 1624 * Create the mailbox structures. Helper function for bha_attach(). 1625 * 1626 * NOTE: The Buslogic hardware only gets one DMA address for the 1627 * mailbox! It expects: 1628 * 1629 * mailbox_out[mailbox_size] 1630 * mailbox_in[mailbox_size] 1631 */ 1632 static int 1633 bha_create_mailbox(struct bha_softc *sc) 1634 { 1635 bus_dma_segment_t seg; 1636 size_t size; 1637 int error, rseg; 1638 1639 size = (sizeof(struct bha_mbx_out) * sc->sc_mbox_count) + 1640 (sizeof(struct bha_mbx_in) * sc->sc_mbox_count); 1641 1642 error = bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &seg, 1643 1, &rseg, sc->sc_dmaflags); 1644 if (error) { 1645 aprint_error("%s: unable to allocate mailboxes, error = %d\n", 1646 sc->sc_dev.dv_xname, error); 1647 goto bad_0; 1648 } 1649 1650 error = bus_dmamem_map(sc->sc_dmat, &seg, rseg, size, 1651 (caddr_t *)&sc->sc_mbo, sc->sc_dmaflags | BUS_DMA_COHERENT); 1652 if (error) { 1653 aprint_error("%s: unable to map mailboxes, error = %d\n", 1654 sc->sc_dev.dv_xname, error); 1655 goto bad_1; 1656 } 1657 1658 memset(sc->sc_mbo, 0, size); 1659 1660 error = bus_dmamap_create(sc->sc_dmat, size, 1, size, 0, 1661 sc->sc_dmaflags, &sc->sc_dmamap_mbox); 1662 if (error) { 1663 aprint_error( 1664 "%s: unable to create mailbox DMA map, error = %d\n", 1665 sc->sc_dev.dv_xname, error); 1666 goto bad_2; 1667 } 1668 1669 error = bus_dmamap_load(sc->sc_dmat, sc->sc_dmamap_mbox, 1670 sc->sc_mbo, size, NULL, 0); 1671 if (error) { 1672 aprint_error("%s: unable to load mailbox DMA map, error = %d\n", 1673 sc->sc_dev.dv_xname, error); 1674 goto bad_3; 1675 } 1676 1677 sc->sc_mbi = (struct bha_mbx_in *)(sc->sc_mbo + sc->sc_mbox_count); 1678 1679 return (0); 1680 1681 bad_3: 1682 bus_dmamap_destroy(sc->sc_dmat, sc->sc_dmamap_mbox); 1683 bad_2: 1684 bus_dmamem_unmap(sc->sc_dmat, (caddr_t)sc->sc_mbo, size); 1685 bad_1: 1686 bus_dmamem_free(sc->sc_dmat, &seg, rseg); 1687 bad_0: 1688 return (error); 1689 } 1690 1691 /* 1692 * bha_collect_mbo: 1693 * 1694 * Garbage collect mailboxes that are no longer in use. 1695 */ 1696 static void 1697 bha_collect_mbo(struct bha_softc *sc) 1698 { 1699 struct bha_mbx_out *mbo; 1700 #ifdef BHADIAG 1701 struct bha_ccb *ccb; 1702 #endif 1703 1704 mbo = sc->sc_cmbo; 1705 1706 while (sc->sc_mbofull > 0) { 1707 BHA_MBO_SYNC(sc, mbo, 1708 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); 1709 if (mbo->cmd != BHA_MBO_FREE) 1710 break; 1711 1712 #ifdef BHADIAG 1713 ccb = bha_ccb_phys_kv(sc, phystol(mbo->ccb_addr)); 1714 ccb->flags &= ~CCB_SENDING; 1715 #endif 1716 1717 --sc->sc_mbofull; 1718 mbo = bha_nextmbo(sc, mbo); 1719 } 1720 1721 sc->sc_cmbo = mbo; 1722 } 1723 1724 /***************************************************************************** 1725 * CCB management functions 1726 *****************************************************************************/ 1727 1728 static inline void 1729 bha_reset_ccb(struct bha_ccb *ccb) 1730 { 1731 1732 ccb->flags = 0; 1733 } 1734 1735 /* 1736 * bha_create_ccbs: 1737 * 1738 * Create a set of CCBs. 1739 * 1740 * We determine the target CCB count, and then keep creating them 1741 * until we reach the target, or fail. CCBs that are allocated 1742 * but not "created" are left on the allocating list. 1743 * 1744 * XXX AB_QUIET/AB_SILENT lossage here; this is called during 1745 * boot as well as at run-time. 1746 */ 1747 static void 1748 bha_create_ccbs(struct bha_softc *sc, int count) 1749 { 1750 struct bha_ccb_group *bcg; 1751 struct bha_ccb *ccb; 1752 bus_dma_segment_t seg; 1753 bus_dmamap_t ccbmap; 1754 int target, i, error, rseg; 1755 1756 /* 1757 * If the current CCB count is already the max number we're 1758 * allowed to have, bail out now. 1759 */ 1760 if (sc->sc_cur_ccbs == sc->sc_max_ccbs) 1761 return; 1762 1763 /* 1764 * Compute our target count, and clamp it down to the max 1765 * number we're allowed to have. 1766 */ 1767 target = sc->sc_cur_ccbs + count; 1768 if (target > sc->sc_max_ccbs) 1769 target = sc->sc_max_ccbs; 1770 1771 /* 1772 * If there are CCBs on the allocating list, don't allocate a 1773 * CCB group yet. 1774 */ 1775 if (TAILQ_FIRST(&sc->sc_allocating_ccbs) != NULL) 1776 goto have_allocating_ccbs; 1777 1778 allocate_group: 1779 error = bus_dmamem_alloc(sc->sc_dmat, PAGE_SIZE, 1780 PAGE_SIZE, 0, &seg, 1, &rseg, sc->sc_dmaflags | BUS_DMA_NOWAIT); 1781 if (error) { 1782 printf("%s: unable to allocate CCB group, error = %d\n", 1783 sc->sc_dev.dv_xname, error); 1784 goto bad_0; 1785 } 1786 1787 error = bus_dmamem_map(sc->sc_dmat, &seg, rseg, PAGE_SIZE, 1788 (void *)&bcg, 1789 sc->sc_dmaflags | BUS_DMA_NOWAIT | BUS_DMA_COHERENT); 1790 if (error) { 1791 printf("%s: unable to map CCB group, error = %d\n", 1792 sc->sc_dev.dv_xname, error); 1793 goto bad_1; 1794 } 1795 1796 memset(bcg, 0, PAGE_SIZE); 1797 1798 error = bus_dmamap_create(sc->sc_dmat, PAGE_SIZE, 1799 1, PAGE_SIZE, 0, sc->sc_dmaflags | BUS_DMA_NOWAIT, &ccbmap); 1800 if (error) { 1801 printf("%s: unable to create CCB group DMA map, error = %d\n", 1802 sc->sc_dev.dv_xname, error); 1803 goto bad_2; 1804 } 1805 1806 error = bus_dmamap_load(sc->sc_dmat, ccbmap, bcg, PAGE_SIZE, NULL, 1807 sc->sc_dmaflags | BUS_DMA_NOWAIT); 1808 if (error) { 1809 printf("%s: unable to load CCB group DMA map, error = %d\n", 1810 sc->sc_dev.dv_xname, error); 1811 goto bad_3; 1812 } 1813 1814 bcg->bcg_dmamap = ccbmap; 1815 1816 #ifdef DIAGNOSTIC 1817 if (BHA_CCB_GROUP(&bcg->bcg_ccbs[0]) != 1818 BHA_CCB_GROUP(&bcg->bcg_ccbs[bha_ccbs_per_group - 1])) 1819 panic("bha_create_ccbs: CCB group size botch"); 1820 #endif 1821 1822 /* 1823 * Add all of the CCBs in this group to the allocating list. 1824 */ 1825 for (i = 0; i < bha_ccbs_per_group; i++) { 1826 ccb = &bcg->bcg_ccbs[i]; 1827 TAILQ_INSERT_TAIL(&sc->sc_allocating_ccbs, ccb, chain); 1828 } 1829 1830 have_allocating_ccbs: 1831 /* 1832 * Loop over the allocating list until we reach our CCB target. 1833 * If we run out on the list, we'll allocate another group's 1834 * worth. 1835 */ 1836 while (sc->sc_cur_ccbs < target) { 1837 ccb = TAILQ_FIRST(&sc->sc_allocating_ccbs); 1838 if (ccb == NULL) 1839 goto allocate_group; 1840 if (bha_init_ccb(sc, ccb) != 0) { 1841 /* 1842 * We were unable to initialize the CCB. 1843 * This is likely due to a resource shortage, 1844 * so bail out now. 1845 */ 1846 return; 1847 } 1848 } 1849 1850 /* 1851 * If we got here, we've reached our target! 1852 */ 1853 return; 1854 1855 bad_3: 1856 bus_dmamap_destroy(sc->sc_dmat, ccbmap); 1857 bad_2: 1858 bus_dmamem_unmap(sc->sc_dmat, (caddr_t)bcg, PAGE_SIZE); 1859 bad_1: 1860 bus_dmamem_free(sc->sc_dmat, &seg, rseg); 1861 bad_0: 1862 return; 1863 } 1864 1865 /* 1866 * bha_init_ccb: 1867 * 1868 * Initialize a CCB; helper function for bha_create_ccbs(). 1869 */ 1870 static int 1871 bha_init_ccb(struct bha_softc *sc, struct bha_ccb *ccb) 1872 { 1873 struct bha_ccb_group *bcg = BHA_CCB_GROUP(ccb); 1874 int hashnum, error; 1875 1876 /* 1877 * Create the DMA map for this CCB. 1878 * 1879 * XXX ALLOCNOW is a hack to prevent bounce buffer shortages 1880 * XXX in the ISA case. A better solution is needed. 1881 */ 1882 error = bus_dmamap_create(sc->sc_dmat, BHA_MAXXFER, BHA_NSEG, 1883 BHA_MAXXFER, 0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW | sc->sc_dmaflags, 1884 &ccb->dmamap_xfer); 1885 if (error) { 1886 printf("%s: unable to create CCB DMA map, error = %d\n", 1887 sc->sc_dev.dv_xname, error); 1888 return (error); 1889 } 1890 1891 TAILQ_REMOVE(&sc->sc_allocating_ccbs, ccb, chain); 1892 1893 /* 1894 * Put the CCB into the phystokv hash table. 1895 */ 1896 ccb->hashkey = bcg->bcg_dmamap->dm_segs[0].ds_addr + 1897 BHA_CCB_OFFSET(ccb); 1898 hashnum = CCB_HASH(ccb->hashkey); 1899 ccb->nexthash = sc->sc_ccbhash[hashnum]; 1900 sc->sc_ccbhash[hashnum] = ccb; 1901 bha_reset_ccb(ccb); 1902 1903 TAILQ_INSERT_HEAD(&sc->sc_free_ccb, ccb, chain); 1904 sc->sc_cur_ccbs++; 1905 1906 return (0); 1907 } 1908 1909 /* 1910 * bha_get_ccb: 1911 * 1912 * Get a CCB for the SCSI operation. If there are none left, 1913 * wait until one becomes available, if we can. 1914 */ 1915 static struct bha_ccb * 1916 bha_get_ccb(struct bha_softc *sc) 1917 { 1918 struct bha_ccb *ccb; 1919 int s; 1920 1921 s = splbio(); 1922 ccb = TAILQ_FIRST(&sc->sc_free_ccb); 1923 if (ccb != NULL) { 1924 TAILQ_REMOVE(&sc->sc_free_ccb, ccb, chain); 1925 ccb->flags |= CCB_ALLOC; 1926 } 1927 splx(s); 1928 return (ccb); 1929 } 1930 1931 /* 1932 * bha_free_ccb: 1933 * 1934 * Put a CCB back onto the free list. 1935 */ 1936 static void 1937 bha_free_ccb(struct bha_softc *sc, struct bha_ccb *ccb) 1938 { 1939 int s; 1940 1941 s = splbio(); 1942 bha_reset_ccb(ccb); 1943 TAILQ_INSERT_HEAD(&sc->sc_free_ccb, ccb, chain); 1944 splx(s); 1945 } 1946 1947 /* 1948 * bha_ccb_phys_kv: 1949 * 1950 * Given a CCB DMA address, locate the CCB in kernel virtual space. 1951 */ 1952 static struct bha_ccb * 1953 bha_ccb_phys_kv(struct bha_softc *sc, bus_addr_t ccb_phys) 1954 { 1955 int hashnum = CCB_HASH(ccb_phys); 1956 struct bha_ccb *ccb = sc->sc_ccbhash[hashnum]; 1957 1958 while (ccb) { 1959 if (ccb->hashkey == ccb_phys) 1960 break; 1961 ccb = ccb->nexthash; 1962 } 1963 return (ccb); 1964 } 1965