ahb.c revision 275982
1/*- 2 * CAM SCSI device driver for the Adaptec 174X SCSI Host adapter 3 * 4 * Copyright (c) 1998 Justin T. Gibbs 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice immediately at the beginning of the file, without modification, 12 * this list of conditions, and the following disclaimer. 13 * 2. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $FreeBSD: stable/10/sys/dev/ahb/ahb.c 275982 2014-12-21 03:06:11Z smh $ 29 */ 30 31#include <sys/param.h> 32#include <sys/conf.h> 33#include <sys/systm.h> 34#include <sys/kernel.h> 35#include <sys/malloc.h> 36#include <sys/module.h> 37#include <sys/lock.h> 38#include <sys/mutex.h> 39#include <sys/bus.h> 40 41#include <machine/bus.h> 42#include <machine/resource.h> 43#include <sys/rman.h> 44 45#include <cam/cam.h> 46#include <cam/cam_ccb.h> 47#include <cam/cam_sim.h> 48#include <cam/cam_xpt_sim.h> 49#include <cam/cam_debug.h> 50 51#include <cam/scsi/scsi_message.h> 52 53#include <dev/eisa/eisaconf.h> 54 55#include <dev/ahb/ahbreg.h> 56 57#define ccb_ecb_ptr spriv_ptr0 58#define ccb_ahb_ptr spriv_ptr1 59 60#define ahb_inb(ahb, port) \ 61 bus_read_1((ahb)->res, port) 62 63#define ahb_inl(ahb, port) \ 64 bus_read_4((ahb)->res, port) 65 66#define ahb_outb(ahb, port, value) \ 67 bus_write_1((ahb)->res, port, value) 68 69#define ahb_outl(ahb, port, value) \ 70 bus_write_4((ahb)->res, port, value) 71 72static const char *ahbmatch(eisa_id_t type); 73static struct ahb_softc *ahballoc(device_t dev, struct resource *res); 74static void ahbfree(struct ahb_softc *ahb); 75static int ahbreset(struct ahb_softc *ahb); 76static void ahbmapecbs(void *arg, bus_dma_segment_t *segs, 77 int nseg, int error); 78static int ahbxptattach(struct ahb_softc *ahb); 79static void ahbhandleimmed(struct ahb_softc *ahb, 80 u_int32_t mbox, u_int intstat); 81static void ahbcalcresid(struct ahb_softc *ahb, 82 struct ecb *ecb, union ccb *ccb); 83static __inline void ahbdone(struct ahb_softc *ahb, u_int32_t mbox, 84 u_int intstat); 85static void ahbintr(void *arg); 86static void ahbintr_locked(struct ahb_softc *ahb); 87static bus_dmamap_callback_t ahbexecuteecb; 88static void ahbaction(struct cam_sim *sim, union ccb *ccb); 89static void ahbpoll(struct cam_sim *sim); 90 91/* Our timeout handler */ 92static void ahbtimeout(void *arg); 93 94static __inline struct ecb* ahbecbget(struct ahb_softc *ahb); 95static __inline void ahbecbfree(struct ahb_softc* ahb, 96 struct ecb* ecb); 97static __inline u_int32_t ahbecbvtop(struct ahb_softc *ahb, 98 struct ecb *ecb); 99static __inline struct ecb* ahbecbptov(struct ahb_softc *ahb, 100 u_int32_t ecb_addr); 101static __inline u_int32_t ahbstatuspaddr(u_int32_t ecb_paddr); 102static __inline u_int32_t ahbsensepaddr(u_int32_t ecb_paddr); 103static __inline u_int32_t ahbsgpaddr(u_int32_t ecb_paddr); 104static __inline void ahbqueuembox(struct ahb_softc *ahb, 105 u_int32_t mboxval, 106 u_int attn_code); 107 108static __inline struct ecb* 109ahbecbget(struct ahb_softc *ahb) 110{ 111 struct ecb* ecb; 112 113 if (!dumping) 114 mtx_assert(&ahb->lock, MA_OWNED); 115 if ((ecb = SLIST_FIRST(&ahb->free_ecbs)) != NULL) 116 SLIST_REMOVE_HEAD(&ahb->free_ecbs, links); 117 118 return (ecb); 119} 120 121static __inline void 122ahbecbfree(struct ahb_softc* ahb, struct ecb* ecb) 123{ 124 125 if (!dumping) 126 mtx_assert(&ahb->lock, MA_OWNED); 127 ecb->state = ECB_FREE; 128 SLIST_INSERT_HEAD(&ahb->free_ecbs, ecb, links); 129} 130 131static __inline u_int32_t 132ahbecbvtop(struct ahb_softc *ahb, struct ecb *ecb) 133{ 134 return (ahb->ecb_physbase 135 + (u_int32_t)((caddr_t)ecb - (caddr_t)ahb->ecb_array)); 136} 137 138static __inline struct ecb* 139ahbecbptov(struct ahb_softc *ahb, u_int32_t ecb_addr) 140{ 141 return (ahb->ecb_array 142 + ((struct ecb*)(uintptr_t)ecb_addr 143 - (struct ecb*)(uintptr_t)ahb->ecb_physbase)); 144} 145 146static __inline u_int32_t 147ahbstatuspaddr(u_int32_t ecb_paddr) 148{ 149 return (ecb_paddr + offsetof(struct ecb, status)); 150} 151 152static __inline u_int32_t 153ahbsensepaddr(u_int32_t ecb_paddr) 154{ 155 return (ecb_paddr + offsetof(struct ecb, sense)); 156} 157 158static __inline u_int32_t 159ahbsgpaddr(u_int32_t ecb_paddr) 160{ 161 return (ecb_paddr + offsetof(struct ecb, sg_list)); 162} 163 164static __inline void 165ahbqueuembox(struct ahb_softc *ahb, u_int32_t mboxval, u_int attn_code) 166{ 167 u_int loopmax = 300; 168 while (--loopmax) { 169 u_int status; 170 171 status = ahb_inb(ahb, HOSTSTAT); 172 if ((status & (HOSTSTAT_MBOX_EMPTY|HOSTSTAT_BUSY)) 173 == HOSTSTAT_MBOX_EMPTY) 174 break; 175 DELAY(20); 176 } 177 if (loopmax == 0) 178 panic("%s: adapter not taking commands\n", 179 device_get_nameunit(ahb->dev)); 180 181 ahb_outl(ahb, MBOXOUT0, mboxval); 182 ahb_outb(ahb, ATTN, attn_code); 183} 184 185static const char * 186ahbmatch(eisa_id_t type) 187{ 188 switch(type & 0xfffffe00) { 189 case EISA_DEVICE_ID_ADAPTEC_1740: 190 return ("Adaptec 174x SCSI host adapter"); 191 break; 192 default: 193 break; 194 } 195 return (NULL); 196} 197 198static int 199ahbprobe(device_t dev) 200{ 201 const char *desc; 202 u_int32_t iobase; 203 u_int32_t irq; 204 u_int8_t intdef; 205 int shared; 206 207 desc = ahbmatch(eisa_get_id(dev)); 208 if (!desc) 209 return (ENXIO); 210 device_set_desc(dev, desc); 211 212 iobase = (eisa_get_slot(dev) * EISA_SLOT_SIZE) + 213 AHB_EISA_SLOT_OFFSET; 214 215 eisa_add_iospace(dev, iobase, AHB_EISA_IOSIZE, RESVADDR_NONE); 216 217 intdef = inb(INTDEF + iobase); 218 switch (intdef & 0x7) { 219 case INT9: 220 irq = 9; 221 break; 222 case INT10: 223 irq = 10; 224 break; 225 case INT11: 226 irq = 11; 227 break; 228 case INT12: 229 irq = 12; 230 break; 231 case INT14: 232 irq = 14; 233 break; 234 case INT15: 235 irq = 15; 236 break; 237 default: 238 printf("Adaptec 174X at slot %d: illegal " 239 "irq setting %d\n", eisa_get_slot(dev), 240 (intdef & 0x7)); 241 irq = 0; 242 break; 243 } 244 if (irq == 0) 245 return ENXIO; 246 247 shared = (inb(INTDEF + iobase) & INTLEVEL) ? 248 EISA_TRIGGER_LEVEL : EISA_TRIGGER_EDGE; 249 250 eisa_add_intr(dev, irq, shared); 251 252 return 0; 253} 254 255static int 256ahbattach(device_t dev) 257{ 258 /* 259 * find unit and check we have that many defined 260 */ 261 struct ahb_softc *ahb; 262 struct ecb* next_ecb; 263 struct resource *io; 264 struct resource *irq; 265 int rid; 266 void *ih; 267 268 irq = NULL; 269 rid = 0; 270 io = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid, RF_ACTIVE); 271 if (io == NULL) { 272 device_printf(dev, "No I/O space?!\n"); 273 return ENOMEM; 274 } 275 276 ahb = ahballoc(dev, io); 277 278 if (ahbreset(ahb) != 0) 279 goto error_exit; 280 281 rid = 0; 282 irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE); 283 if (irq == NULL) { 284 device_printf(dev, "Can't allocate interrupt\n"); 285 goto error_exit; 286 } 287 288 /* 289 * Create our DMA tags. These tags define the kinds of device 290 * accessible memory allocations and memory mappings we will 291 * need to perform during normal operation. 292 */ 293 /* DMA tag for mapping buffers into device visible space. */ 294 if (bus_dma_tag_create( /* parent */ bus_get_dma_tag(dev), 295 /* alignment */ 1, 296 /* boundary */ 0, 297 /* lowaddr */ BUS_SPACE_MAXADDR_32BIT, 298 /* highaddr */ BUS_SPACE_MAXADDR, 299 /* filter */ NULL, 300 /* filterarg */ NULL, 301 /* maxsize */ MAXBSIZE, 302 /* nsegments */ AHB_NSEG, 303 /* maxsegsz */ BUS_SPACE_MAXSIZE_32BIT, 304 /* flags */ BUS_DMA_ALLOCNOW, 305 /* lockfunc */ busdma_lock_mutex, 306 /* lockarg */ &ahb->lock, 307 &ahb->buffer_dmat) != 0) 308 goto error_exit; 309 310 ahb->init_level++; 311 312 /* DMA tag for our ccb structures and ha inquiry data */ 313 if (bus_dma_tag_create( /* parent */ bus_get_dma_tag(dev), 314 /* alignment */ 1, 315 /* boundary */ 0, 316 /* lowaddr */ BUS_SPACE_MAXADDR_32BIT, 317 /* highaddr */ BUS_SPACE_MAXADDR, 318 /* filter */ NULL, 319 /* filterarg */ NULL, 320 /* maxsize */ (AHB_NECB * 321 sizeof(struct ecb)) 322 + sizeof(*ahb->ha_inq_data), 323 /* nsegments */ 1, 324 /* maxsegsz */ BUS_SPACE_MAXSIZE_32BIT, 325 /* flags */ 0, 326 /* lockfunc */ NULL, 327 /* lockarg */ NULL, 328 &ahb->ecb_dmat) != 0) 329 goto error_exit; 330 331 ahb->init_level++; 332 333 /* Allocation for our ccbs */ 334 if (bus_dmamem_alloc(ahb->ecb_dmat, (void **)&ahb->ecb_array, 335 BUS_DMA_NOWAIT, &ahb->ecb_dmamap) != 0) 336 goto error_exit; 337 338 ahb->ha_inq_data = (struct ha_inquiry_data *)&ahb->ecb_array[AHB_NECB]; 339 340 ahb->init_level++; 341 342 /* And permanently map them */ 343 bus_dmamap_load(ahb->ecb_dmat, ahb->ecb_dmamap, 344 ahb->ecb_array, AHB_NSEG * sizeof(struct ecb), 345 ahbmapecbs, ahb, /*flags*/0); 346 347 ahb->init_level++; 348 349 /* Allocate the buffer dmamaps for each of our ECBs */ 350 bzero(ahb->ecb_array, (AHB_NECB * sizeof(struct ecb)) 351 + sizeof(*ahb->ha_inq_data)); 352 next_ecb = ahb->ecb_array; 353 while (ahb->num_ecbs < AHB_NECB) { 354 u_int32_t ecb_paddr; 355 356 if (bus_dmamap_create(ahb->buffer_dmat, /*flags*/0, 357 &next_ecb->dmamap)) 358 break; 359 callout_init_mtx(&next_ecb->timer, &ahb->lock, 0); 360 ecb_paddr = ahbecbvtop(ahb, next_ecb); 361 next_ecb->hecb.status_ptr = ahbstatuspaddr(ecb_paddr); 362 next_ecb->hecb.sense_ptr = ahbsensepaddr(ecb_paddr); 363 ahb->num_ecbs++; 364 ahbecbfree(ahb, next_ecb); 365 next_ecb++; 366 } 367 368 ahb->init_level++; 369 370 /* 371 * Now that we know we own the resources we need, register 372 * our bus with the XPT. 373 */ 374 if (ahbxptattach(ahb)) 375 goto error_exit; 376 377 /* Enable our interrupt */ 378 if (bus_setup_intr(dev, irq, INTR_TYPE_CAM|INTR_ENTROPY|INTR_MPSAFE, 379 NULL, ahbintr, ahb, &ih) != 0) 380 goto error_exit; 381 382 return (0); 383 384error_exit: 385 /* 386 * The board's IRQ line will not be left enabled 387 * if we can't initialize correctly, so its safe 388 * to release the irq. 389 */ 390 ahbfree(ahb); 391 if (irq != NULL) 392 bus_release_resource(dev, SYS_RES_IRQ, 0, irq); 393 bus_release_resource(dev, SYS_RES_IOPORT, 0, io); 394 return (-1); 395} 396 397static struct ahb_softc * 398ahballoc(device_t dev, struct resource *res) 399{ 400 struct ahb_softc *ahb; 401 402 ahb = device_get_softc(dev); 403 SLIST_INIT(&ahb->free_ecbs); 404 LIST_INIT(&ahb->pending_ccbs); 405 ahb->res = res; 406 ahb->disc_permitted = ~0; 407 ahb->tags_permitted = ~0; 408 ahb->dev = dev; 409 mtx_init(&ahb->lock, "ahb", NULL, MTX_DEF); 410 411 return (ahb); 412} 413 414static void 415ahbfree(struct ahb_softc *ahb) 416{ 417 switch (ahb->init_level) { 418 default: 419 case 4: 420 bus_dmamap_unload(ahb->ecb_dmat, ahb->ecb_dmamap); 421 case 3: 422 bus_dmamem_free(ahb->ecb_dmat, ahb->ecb_array, 423 ahb->ecb_dmamap); 424 bus_dmamap_destroy(ahb->ecb_dmat, ahb->ecb_dmamap); 425 case 2: 426 bus_dma_tag_destroy(ahb->ecb_dmat); 427 case 1: 428 bus_dma_tag_destroy(ahb->buffer_dmat); 429 case 0: 430 break; 431 } 432 mtx_destroy(&ahb->lock); 433} 434 435/* 436 * reset board, If it doesn't respond, return failure 437 */ 438static int 439ahbreset(struct ahb_softc *ahb) 440{ 441 int wait = 1000; /* 1 sec enough? */ 442 int test; 443 444 if ((ahb_inb(ahb, PORTADDR) & PORTADDR_ENHANCED) == 0) { 445 printf("ahb_reset: Controller not in enhanced mode\n"); 446 return (-1); 447 } 448 449 ahb_outb(ahb, CONTROL, CNTRL_HARD_RST); 450 DELAY(1000); 451 ahb_outb(ahb, CONTROL, 0); 452 while (--wait) { 453 DELAY(1000); 454 if ((ahb_inb(ahb, HOSTSTAT) & HOSTSTAT_BUSY) == 0) 455 break; 456 } 457 458 if (wait == 0) { 459 printf("ahbreset: No answer from aha1742 board\n"); 460 return (-1); 461 } 462 if ((test = ahb_inb(ahb, MBOXIN0)) != 0) { 463 printf("ahb_reset: self test failed, val = 0x%x\n", test); 464 return (-1); 465 } 466 while (ahb_inb(ahb, HOSTSTAT) & HOSTSTAT_INTPEND) { 467 ahb_outb(ahb, CONTROL, CNTRL_CLRINT); 468 DELAY(10000); 469 } 470 return (0); 471} 472 473static void 474ahbmapecbs(void *arg, bus_dma_segment_t *segs, int nseg, int error) 475{ 476 struct ahb_softc* ahb; 477 478 ahb = (struct ahb_softc*)arg; 479 ahb->ecb_physbase = segs->ds_addr; 480 /* 481 * Space for adapter inquiry information is on the 482 * tail of the ecb array. 483 */ 484 ahb->ha_inq_physbase = ahbecbvtop(ahb, &ahb->ecb_array[AHB_NECB]); 485} 486 487static int 488ahbxptattach(struct ahb_softc *ahb) 489{ 490 struct cam_devq *devq; 491 struct ecb *ecb; 492 u_int i; 493 494 mtx_lock(&ahb->lock); 495 496 /* Remember who are we on the scsi bus */ 497 ahb->scsi_id = ahb_inb(ahb, SCSIDEF) & HSCSIID; 498 499 /* Use extended translation?? */ 500 ahb->extended_trans = ahb_inb(ahb, RESV1) & EXTENDED_TRANS; 501 502 /* Fetch adapter inquiry data */ 503 ecb = ahbecbget(ahb); /* Always succeeds - no outstanding commands */ 504 ecb->hecb.opcode = ECBOP_READ_HA_INQDATA; 505 ecb->hecb.flag_word1 = FW1_SUPPRESS_URUN_ERR|FW1_ERR_STATUS_BLK_ONLY; 506 ecb->hecb.data_ptr = ahb->ha_inq_physbase; 507 ecb->hecb.data_len = sizeof(struct ha_inquiry_data); 508 ecb->hecb.sense_ptr = 0; 509 ecb->state = ECB_ACTIVE; 510 511 /* Tell the adapter about this command */ 512 ahbqueuembox(ahb, ahbecbvtop(ahb, ecb), 513 ATTN_STARTECB|ahb->scsi_id); 514 515 /* Poll for interrupt completion */ 516 for (i = 1000; ecb->state != ECB_FREE && i != 0; i--) { 517 ahbintr_locked(ahb); 518 DELAY(1000); 519 } 520 521 ahb->num_ecbs = MIN(ahb->num_ecbs, 522 ahb->ha_inq_data->scsi_data.spc2_flags); 523 device_printf(ahb->dev, 524 "%.8s %s SCSI Adapter, FW Rev. %.4s, ID=%d, %d ECBs\n", 525 ahb->ha_inq_data->scsi_data.product, 526 (ahb->ha_inq_data->scsi_data.flags & 0x4) ? "Differential" 527 : "Single Ended", 528 ahb->ha_inq_data->scsi_data.revision, 529 ahb->scsi_id, ahb->num_ecbs); 530 531 /* Restore sense paddr for future CCB clients */ 532 ecb->hecb.sense_ptr = ahbsensepaddr(ahbecbvtop(ahb, ecb)); 533 534 ahbecbfree(ahb, ecb); 535 536 /* 537 * Create the device queue for our SIM. 538 */ 539 devq = cam_simq_alloc(ahb->num_ecbs); 540 if (devq == NULL) { 541 mtx_unlock(&ahb->lock); 542 return (ENOMEM); 543 } 544 545 /* 546 * Construct our SIM entry 547 */ 548 ahb->sim = cam_sim_alloc(ahbaction, ahbpoll, "ahb", ahb, 549 device_get_unit(ahb->dev), &ahb->lock, 2, ahb->num_ecbs, devq); 550 if (ahb->sim == NULL) { 551 cam_simq_free(devq); 552 mtx_unlock(&ahb->lock); 553 return (ENOMEM); 554 } 555 556 if (xpt_bus_register(ahb->sim, ahb->dev, 0) != CAM_SUCCESS) { 557 cam_sim_free(ahb->sim, /*free_devq*/TRUE); 558 mtx_unlock(&ahb->lock); 559 return (ENXIO); 560 } 561 562 if (xpt_create_path(&ahb->path, /*periph*/NULL, 563 cam_sim_path(ahb->sim), CAM_TARGET_WILDCARD, 564 CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 565 xpt_bus_deregister(cam_sim_path(ahb->sim)); 566 cam_sim_free(ahb->sim, /*free_devq*/TRUE); 567 mtx_unlock(&ahb->lock); 568 return (ENXIO); 569 } 570 571 /* 572 * Allow the board to generate interrupts. 573 */ 574 ahb_outb(ahb, INTDEF, ahb_inb(ahb, INTDEF) | INTEN); 575 mtx_unlock(&ahb->lock); 576 577 return (0); 578} 579 580static void 581ahbhandleimmed(struct ahb_softc *ahb, u_int32_t mbox, u_int intstat) 582{ 583 struct ccb_hdr *ccb_h; 584 u_int target_id; 585 586 if (ahb->immed_cmd == 0) { 587 device_printf(ahb->dev, "Immediate Command complete with no " 588 " pending command\n"); 589 return; 590 } 591 592 target_id = intstat & INTSTAT_TARGET_MASK; 593 594 ccb_h = LIST_FIRST(&ahb->pending_ccbs); 595 while (ccb_h != NULL) { 596 struct ecb *pending_ecb; 597 union ccb *ccb; 598 599 pending_ecb = (struct ecb *)ccb_h->ccb_ecb_ptr; 600 ccb = pending_ecb->ccb; 601 ccb_h = LIST_NEXT(ccb_h, sim_links.le); 602 if (ccb->ccb_h.target_id == target_id 603 || target_id == ahb->scsi_id) { 604 callout_stop(&pending_ecb->timer); 605 LIST_REMOVE(&ccb->ccb_h, sim_links.le); 606 if ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE) 607 bus_dmamap_unload(ahb->buffer_dmat, 608 pending_ecb->dmamap); 609 if (pending_ecb == ahb->immed_ecb) 610 ccb->ccb_h.status = 611 CAM_CMD_TIMEOUT|CAM_RELEASE_SIMQ; 612 else if (target_id == ahb->scsi_id) 613 ccb->ccb_h.status = CAM_SCSI_BUS_RESET; 614 else 615 ccb->ccb_h.status = CAM_BDR_SENT; 616 ahbecbfree(ahb, pending_ecb); 617 xpt_done(ccb); 618 } else if (ahb->immed_ecb != NULL) { 619 /* Re-instate timeout */ 620 callout_reset_sbt(&pending_ecb->timer, 621 SBT_1MS * ccb->ccb_h.timeout, 0, ahbtimeout, 622 pending_ecb, 0); 623 } 624 } 625 626 if (ahb->immed_ecb != NULL) { 627 ahb->immed_ecb = NULL; 628 device_printf(ahb->dev, "No longer in timeout\n"); 629 } else if (target_id == ahb->scsi_id) 630 device_printf(ahb->dev, "SCSI Bus Reset Delivered\n"); 631 else 632 device_printf(ahb->dev, 633 "Bus Device Reset Delivered to target %d\n", target_id); 634 635 ahb->immed_cmd = 0; 636} 637 638static void 639ahbcalcresid(struct ahb_softc *ahb, struct ecb *ecb, union ccb *ccb) 640{ 641 if (ecb->status.data_overrun != 0) { 642 /* 643 * Overrun Condition. The hardware doesn't 644 * provide a meaningful byte count in this case 645 * (the residual is always 0). Tell the XPT 646 * layer about the error. 647 */ 648 ccb->ccb_h.status = CAM_DATA_RUN_ERR; 649 } else { 650 ccb->csio.resid = ecb->status.resid_count; 651 652 if ((ecb->hecb.flag_word1 & FW1_SG_ECB) != 0) { 653 /* 654 * For S/G transfers, the adapter provides a pointer 655 * to the address in the last S/G element used and a 656 * residual for that element. So, we need to sum up 657 * the elements that follow it in order to get a real 658 * residual number. If we have an overrun, the residual 659 * reported will be 0 and we already know that all S/G 660 * segments have been exhausted, so we can skip this 661 * step. 662 */ 663 ahb_sg_t *sg; 664 int num_sg; 665 666 num_sg = ecb->hecb.data_len / sizeof(ahb_sg_t); 667 668 /* Find the S/G the adapter was working on */ 669 for (sg = ecb->sg_list; 670 num_sg != 0 && sg->addr != ecb->status.resid_addr; 671 num_sg--, sg++) 672 ; 673 674 /* Skip it */ 675 num_sg--; 676 sg++; 677 678 /* Sum the rest */ 679 for (; num_sg != 0; num_sg--, sg++) 680 ccb->csio.resid += sg->len; 681 } 682 /* Underruns are not errors */ 683 ccb->ccb_h.status = CAM_REQ_CMP; 684 } 685} 686 687static void 688ahbprocesserror(struct ahb_softc *ahb, struct ecb *ecb, union ccb *ccb) 689{ 690 struct hardware_ecb *hecb; 691 struct ecb_status *status; 692 693 hecb = &ecb->hecb; 694 status = &ecb->status; 695 switch (status->ha_status) { 696 case HS_OK: 697 ccb->csio.scsi_status = status->scsi_status; 698 if (status->scsi_status != 0) { 699 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR; 700 if (status->sense_stored) { 701 ccb->ccb_h.status |= CAM_AUTOSNS_VALID; 702 ccb->csio.sense_resid = 703 ccb->csio.sense_len - status->sense_len; 704 bcopy(&ecb->sense, &ccb->csio.sense_data, 705 status->sense_len); 706 } 707 } 708 break; 709 case HS_TARGET_NOT_ASSIGNED: 710 ccb->ccb_h.status = CAM_PATH_INVALID; 711 break; 712 case HS_SEL_TIMEOUT: 713 ccb->ccb_h.status = CAM_SEL_TIMEOUT; 714 break; 715 case HS_DATA_RUN_ERR: 716 ahbcalcresid(ahb, ecb, ccb); 717 break; 718 case HS_UNEXPECTED_BUSFREE: 719 ccb->ccb_h.status = CAM_UNEXP_BUSFREE; 720 break; 721 case HS_INVALID_PHASE: 722 ccb->ccb_h.status = CAM_SEQUENCE_FAIL; 723 break; 724 case HS_REQUEST_SENSE_FAILED: 725 ccb->ccb_h.status = CAM_AUTOSENSE_FAIL; 726 break; 727 case HS_TAG_MSG_REJECTED: 728 { 729 struct ccb_trans_settings neg; 730 struct ccb_trans_settings_scsi *scsi = &neg.proto_specific.scsi; 731 732 xpt_print_path(ccb->ccb_h.path); 733 printf("refuses tagged commands. Performing " 734 "non-tagged I/O\n"); 735 memset(&neg, 0, sizeof (neg)); 736 neg.protocol = PROTO_SCSI; 737 neg.protocol_version = SCSI_REV_2; 738 neg.transport = XPORT_SPI; 739 neg.transport_version = 2; 740 scsi->flags = CTS_SCSI_VALID_TQ; 741 xpt_setup_ccb(&neg.ccb_h, ccb->ccb_h.path, /*priority*/1); 742 xpt_async(AC_TRANSFER_NEG, ccb->ccb_h.path, &neg); 743 ahb->tags_permitted &= ~(0x01 << ccb->ccb_h.target_id); 744 ccb->ccb_h.status = CAM_MSG_REJECT_REC; 745 break; 746 } 747 case HS_FIRMWARE_LOAD_REQ: 748 case HS_HARDWARE_ERR: 749 /* 750 * Tell the system that the Adapter 751 * is no longer functional. 752 */ 753 ccb->ccb_h.status = CAM_NO_HBA; 754 break; 755 case HS_CMD_ABORTED_HOST: 756 case HS_CMD_ABORTED_ADAPTER: 757 case HS_ATN_TARGET_FAILED: 758 case HS_SCSI_RESET_ADAPTER: 759 case HS_SCSI_RESET_INCOMING: 760 ccb->ccb_h.status = CAM_SCSI_BUS_RESET; 761 break; 762 case HS_INVALID_ECB_PARAM: 763 device_printf(ahb->dev, 764 "opcode 0x%02x, flag_word1 0x%02x, flag_word2 0x%02x\n", 765 hecb->opcode, hecb->flag_word1, hecb->flag_word2); 766 ccb->ccb_h.status = CAM_SCSI_BUS_RESET; 767 break; 768 case HS_DUP_TCB_RECEIVED: 769 case HS_INVALID_OPCODE: 770 case HS_INVALID_CMD_LINK: 771 case HS_PROGRAM_CKSUM_ERROR: 772 panic("%s: Can't happen host status %x occurred", 773 device_get_nameunit(ahb->dev), status->ha_status); 774 break; 775 } 776 if (ccb->ccb_h.status != CAM_REQ_CMP) { 777 xpt_freeze_devq(ccb->ccb_h.path, /*count*/1); 778 ccb->ccb_h.status |= CAM_DEV_QFRZN; 779 } 780} 781 782static void 783ahbdone(struct ahb_softc *ahb, u_int32_t mbox, u_int intstat) 784{ 785 struct ecb *ecb; 786 union ccb *ccb; 787 788 ecb = ahbecbptov(ahb, mbox); 789 790 if ((ecb->state & ECB_ACTIVE) == 0) 791 panic("ecb not active"); 792 793 ccb = ecb->ccb; 794 795 if (ccb != NULL) { 796 callout_stop(&ecb->timer); 797 LIST_REMOVE(&ccb->ccb_h, sim_links.le); 798 799 if ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE) { 800 bus_dmasync_op_t op; 801 802 if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) 803 op = BUS_DMASYNC_POSTREAD; 804 else 805 op = BUS_DMASYNC_POSTWRITE; 806 bus_dmamap_sync(ahb->buffer_dmat, ecb->dmamap, op); 807 bus_dmamap_unload(ahb->buffer_dmat, ecb->dmamap); 808 } 809 810 if ((intstat & INTSTAT_MASK) == INTSTAT_ECB_OK) { 811 ccb->ccb_h.status = CAM_REQ_CMP; 812 ccb->csio.resid = 0; 813 } else { 814 ahbprocesserror(ahb, ecb, ccb); 815 } 816 ahbecbfree(ahb, ecb); 817 xpt_done(ccb); 818 } else { 819 /* Non CCB Command */ 820 if ((intstat & INTSTAT_MASK) != INTSTAT_ECB_OK) { 821 device_printf(ahb->dev, "Command 0%x Failed %x:%x:%x\n", 822 ecb->hecb.opcode, 823 *((u_int16_t*)&ecb->status), 824 ecb->status.ha_status, ecb->status.resid_count); 825 } 826 /* Client owns this ECB and will release it. */ 827 } 828} 829 830/* 831 * Catch an interrupt from the adaptor 832 */ 833static void 834ahbintr(void *arg) 835{ 836 struct ahb_softc *ahb; 837 838 ahb = arg; 839 mtx_lock(&ahb->lock); 840 ahbintr_locked(ahb); 841 mtx_unlock(&ahb->lock); 842} 843 844static void 845ahbintr_locked(struct ahb_softc *ahb) 846{ 847 u_int intstat; 848 u_int32_t mbox; 849 850 while (ahb_inb(ahb, HOSTSTAT) & HOSTSTAT_INTPEND) { 851 /* 852 * Fetch information about this interrupt. 853 */ 854 intstat = ahb_inb(ahb, INTSTAT); 855 mbox = ahb_inl(ahb, MBOXIN0); 856 857 /* 858 * Reset interrupt latch. 859 */ 860 ahb_outb(ahb, CONTROL, CNTRL_CLRINT); 861 862 /* 863 * Process the completed operation 864 */ 865 switch (intstat & INTSTAT_MASK) { 866 case INTSTAT_ECB_OK: 867 case INTSTAT_ECB_CMPWRETRY: 868 case INTSTAT_ECB_CMPWERR: 869 ahbdone(ahb, mbox, intstat); 870 break; 871 case INTSTAT_AEN_OCCURED: 872 if ((intstat & INTSTAT_TARGET_MASK) == ahb->scsi_id) { 873 /* Bus Reset */ 874 xpt_print_path(ahb->path); 875 switch (mbox) { 876 case HS_SCSI_RESET_ADAPTER: 877 printf("Host Adapter Initiated " 878 "Bus Reset occurred\n"); 879 break; 880 case HS_SCSI_RESET_INCOMING: 881 printf("Bus Reset Initiated " 882 "by another device occurred\n"); 883 break; 884 } 885 /* Notify the XPT */ 886 xpt_async(AC_BUS_RESET, ahb->path, NULL); 887 break; 888 } 889 printf("Unsupported initiator selection AEN occured\n"); 890 break; 891 case INTSTAT_IMMED_OK: 892 case INTSTAT_IMMED_ERR: 893 ahbhandleimmed(ahb, mbox, intstat); 894 break; 895 case INTSTAT_HW_ERR: 896 panic("Unrecoverable hardware Error Occurred\n"); 897 } 898 } 899} 900 901static void 902ahbexecuteecb(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error) 903{ 904 struct ecb *ecb; 905 union ccb *ccb; 906 struct ahb_softc *ahb; 907 u_int32_t ecb_paddr; 908 909 ecb = (struct ecb *)arg; 910 ccb = ecb->ccb; 911 ahb = (struct ahb_softc *)ccb->ccb_h.ccb_ahb_ptr; 912 mtx_assert(&ahb->lock, MA_OWNED); 913 914 if (error != 0) { 915 if (error != EFBIG) 916 device_printf(ahb->dev, 917 "Unexepected error 0x%x returned from " 918 "bus_dmamap_load\n", error); 919 if (ccb->ccb_h.status == CAM_REQ_INPROG) { 920 xpt_freeze_devq(ccb->ccb_h.path, /*count*/1); 921 ccb->ccb_h.status = CAM_REQ_TOO_BIG|CAM_DEV_QFRZN; 922 } 923 ahbecbfree(ahb, ecb); 924 xpt_done(ccb); 925 return; 926 } 927 928 ecb_paddr = ahbecbvtop(ahb, ecb); 929 930 if (nseg != 0) { 931 ahb_sg_t *sg; 932 bus_dma_segment_t *end_seg; 933 bus_dmasync_op_t op; 934 935 end_seg = dm_segs + nseg; 936 937 /* Copy the segments into our SG list */ 938 sg = ecb->sg_list; 939 while (dm_segs < end_seg) { 940 sg->addr = dm_segs->ds_addr; 941 sg->len = dm_segs->ds_len; 942 sg++; 943 dm_segs++; 944 } 945 946 if (nseg > 1) { 947 ecb->hecb.flag_word1 |= FW1_SG_ECB; 948 ecb->hecb.data_ptr = ahbsgpaddr(ecb_paddr); 949 ecb->hecb.data_len = sizeof(ahb_sg_t) * nseg; 950 } else { 951 ecb->hecb.data_ptr = ecb->sg_list->addr; 952 ecb->hecb.data_len = ecb->sg_list->len; 953 } 954 955 if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) { 956/* ecb->hecb.flag_word2 |= FW2_DATA_DIR_IN; */ 957 op = BUS_DMASYNC_PREREAD; 958 } else { 959 op = BUS_DMASYNC_PREWRITE; 960 } 961 /* ecb->hecb.flag_word2 |= FW2_CHECK_DATA_DIR; */ 962 963 bus_dmamap_sync(ahb->buffer_dmat, ecb->dmamap, op); 964 965 } else { 966 ecb->hecb.data_ptr = 0; 967 ecb->hecb.data_len = 0; 968 } 969 970 /* 971 * Last time we need to check if this CCB needs to 972 * be aborted. 973 */ 974 if (ccb->ccb_h.status != CAM_REQ_INPROG) { 975 if (nseg != 0) 976 bus_dmamap_unload(ahb->buffer_dmat, ecb->dmamap); 977 ahbecbfree(ahb, ecb); 978 xpt_done(ccb); 979 return; 980 } 981 982 ecb->state = ECB_ACTIVE; 983 ccb->ccb_h.status |= CAM_SIM_QUEUED; 984 LIST_INSERT_HEAD(&ahb->pending_ccbs, &ccb->ccb_h, sim_links.le); 985 986 /* Tell the adapter about this command */ 987 ahbqueuembox(ahb, ecb_paddr, ATTN_STARTECB|ccb->ccb_h.target_id); 988 989 callout_reset_sbt(&ecb->timer, SBT_1MS * ccb->ccb_h.timeout, 0, 990 ahbtimeout, ecb, 0); 991} 992 993static void 994ahbaction(struct cam_sim *sim, union ccb *ccb) 995{ 996 struct ahb_softc *ahb; 997 998 CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, ("ahbaction\n")); 999 1000 ahb = (struct ahb_softc *)cam_sim_softc(sim); 1001 mtx_assert(&ahb->lock, MA_OWNED); 1002 1003 switch (ccb->ccb_h.func_code) { 1004 /* Common cases first */ 1005 case XPT_SCSI_IO: /* Execute the requested I/O operation */ 1006 { 1007 struct ecb *ecb; 1008 struct hardware_ecb *hecb; 1009 int error; 1010 1011 /* 1012 * get an ecb to use. 1013 */ 1014 if ((ecb = ahbecbget(ahb)) == NULL) { 1015 /* Should never occur */ 1016 panic("Failed to get an ecb"); 1017 } 1018 1019 /* 1020 * So we can find the ECB when an abort is requested 1021 */ 1022 ecb->ccb = ccb; 1023 ccb->ccb_h.ccb_ecb_ptr = ecb; 1024 ccb->ccb_h.ccb_ahb_ptr = ahb; 1025 1026 /* 1027 * Put all the arguments for the xfer in the ecb 1028 */ 1029 hecb = &ecb->hecb; 1030 hecb->opcode = ECBOP_INITIATOR_SCSI_CMD; 1031 hecb->flag_word1 = FW1_AUTO_REQUEST_SENSE 1032 | FW1_ERR_STATUS_BLK_ONLY; 1033 hecb->flag_word2 = ccb->ccb_h.target_lun 1034 | FW2_NO_RETRY_ON_BUSY; 1035 if ((ccb->ccb_h.flags & CAM_TAG_ACTION_VALID) != 0) { 1036 hecb->flag_word2 |= FW2_TAG_ENB 1037 | ((ccb->csio.tag_action & 0x3) 1038 << FW2_TAG_TYPE_SHIFT); 1039 } 1040 if ((ccb->ccb_h.flags & CAM_DIS_DISCONNECT) != 0) 1041 hecb->flag_word2 |= FW2_DISABLE_DISC; 1042 hecb->sense_len = ccb->csio.sense_len; 1043 hecb->cdb_len = ccb->csio.cdb_len; 1044 if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0) { 1045 if ((ccb->ccb_h.flags & CAM_CDB_PHYS) == 0) { 1046 bcopy(ccb->csio.cdb_io.cdb_ptr, 1047 hecb->cdb, hecb->cdb_len); 1048 } else { 1049 /* I guess I could map it in... */ 1050 ccb->ccb_h.status = CAM_REQ_INVALID; 1051 ahbecbfree(ahb, ecb); 1052 xpt_done(ccb); 1053 return; 1054 } 1055 } else { 1056 bcopy(ccb->csio.cdb_io.cdb_bytes, 1057 hecb->cdb, hecb->cdb_len); 1058 } 1059 1060 error = bus_dmamap_load_ccb( 1061 ahb->buffer_dmat, 1062 ecb->dmamap, 1063 ccb, 1064 ahbexecuteecb, 1065 ecb, /*flags*/0); 1066 if (error == EINPROGRESS) { 1067 /* 1068 * So as to maintain ordering, freeze the controller 1069 * queue until our mapping is returned. 1070 */ 1071 xpt_freeze_simq(ahb->sim, 1); 1072 ccb->ccb_h.status |= CAM_RELEASE_SIMQ; 1073 } 1074 break; 1075 } 1076 case XPT_EN_LUN: /* Enable LUN as a target */ 1077 case XPT_TARGET_IO: /* Execute target I/O request */ 1078 case XPT_ACCEPT_TARGET_IO: /* Accept Host Target Mode CDB */ 1079 case XPT_CONT_TARGET_IO: /* Continue Host Target I/O Connection*/ 1080 case XPT_ABORT: /* Abort the specified CCB */ 1081 /* XXX Implement */ 1082 ccb->ccb_h.status = CAM_REQ_INVALID; 1083 xpt_done(ccb); 1084 break; 1085 case XPT_SET_TRAN_SETTINGS: 1086 { 1087 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 1088 xpt_done(ccb); 1089 break; 1090 } 1091 case XPT_GET_TRAN_SETTINGS: 1092 /* Get default/user set transfer settings for the target */ 1093 { 1094 struct ccb_trans_settings *cts = &ccb->cts; 1095 u_int target_mask = 0x01 << ccb->ccb_h.target_id; 1096 struct ccb_trans_settings_scsi *scsi = 1097 &cts->proto_specific.scsi; 1098 struct ccb_trans_settings_spi *spi = 1099 &cts->xport_specific.spi; 1100 1101 if (cts->type == CTS_TYPE_USER_SETTINGS) { 1102 cts->protocol = PROTO_SCSI; 1103 cts->protocol_version = SCSI_REV_2; 1104 cts->transport = XPORT_SPI; 1105 cts->transport_version = 2; 1106 1107 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB; 1108 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB; 1109 if ((ahb->disc_permitted & target_mask) != 0) 1110 spi->flags |= CTS_SPI_FLAGS_DISC_ENB; 1111 if ((ahb->tags_permitted & target_mask) != 0) 1112 scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB; 1113 spi->bus_width = MSG_EXT_WDTR_BUS_8_BIT; 1114 spi->sync_period = 25; /* 10MHz */ 1115 1116 if (spi->sync_period != 0) 1117 spi->sync_offset = 15; 1118 1119 spi->valid = CTS_SPI_VALID_SYNC_RATE 1120 | CTS_SPI_VALID_SYNC_OFFSET 1121 | CTS_SPI_VALID_BUS_WIDTH 1122 | CTS_SPI_VALID_DISC; 1123 scsi->valid = CTS_SCSI_VALID_TQ; 1124 ccb->ccb_h.status = CAM_REQ_CMP; 1125 } else { 1126 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 1127 } 1128 xpt_done(ccb); 1129 break; 1130 } 1131 case XPT_RESET_DEV: /* Bus Device Reset the specified SCSI device */ 1132 { 1133 int i; 1134 1135 ahb->immed_cmd = IMMED_RESET; 1136 ahbqueuembox(ahb, IMMED_RESET, ATTN_IMMED|ccb->ccb_h.target_id); 1137 /* Poll for interrupt completion */ 1138 for (i = 1000; ahb->immed_cmd != 0 && i != 0; i--) { 1139 DELAY(1000); 1140 ahbintr_locked(cam_sim_softc(sim)); 1141 } 1142 break; 1143 } 1144 case XPT_CALC_GEOMETRY: 1145 { 1146 cam_calc_geometry(&ccb->ccg, ahb->extended_trans); 1147 xpt_done(ccb); 1148 break; 1149 } 1150 case XPT_RESET_BUS: /* Reset the specified SCSI bus */ 1151 { 1152 int i; 1153 1154 ahb->immed_cmd = IMMED_RESET; 1155 ahbqueuembox(ahb, IMMED_RESET, ATTN_IMMED|ahb->scsi_id); 1156 /* Poll for interrupt completion */ 1157 for (i = 1000; ahb->immed_cmd != 0 && i != 0; i--) 1158 DELAY(1000); 1159 ccb->ccb_h.status = CAM_REQ_CMP; 1160 xpt_done(ccb); 1161 break; 1162 } 1163 case XPT_TERM_IO: /* Terminate the I/O process */ 1164 /* XXX Implement */ 1165 ccb->ccb_h.status = CAM_REQ_INVALID; 1166 xpt_done(ccb); 1167 break; 1168 case XPT_PATH_INQ: /* Path routing inquiry */ 1169 { 1170 struct ccb_pathinq *cpi = &ccb->cpi; 1171 1172 cpi->version_num = 1; /* XXX??? */ 1173 cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE; 1174 cpi->target_sprt = 0; 1175 cpi->hba_misc = 0; 1176 cpi->hba_eng_cnt = 0; 1177 cpi->max_target = 7; 1178 cpi->max_lun = 7; 1179 cpi->initiator_id = ahb->scsi_id; 1180 cpi->bus_id = cam_sim_bus(sim); 1181 cpi->base_transfer_speed = 3300; 1182 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 1183 strncpy(cpi->hba_vid, "Adaptec", HBA_IDLEN); 1184 strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN); 1185 cpi->unit_number = cam_sim_unit(sim); 1186 cpi->transport = XPORT_SPI; 1187 cpi->transport_version = 2; 1188 cpi->protocol = PROTO_SCSI; 1189 cpi->protocol_version = SCSI_REV_2; 1190 cpi->ccb_h.status = CAM_REQ_CMP; 1191 xpt_done(ccb); 1192 break; 1193 } 1194#if 0 1195 /* Need these??? */ 1196 case XPT_IMMED_NOTIFY: /* Notify Host Target driver of event */ 1197 case XPT_NOTIFY_ACK: /* Acknowledgement of event */ 1198#endif 1199 default: 1200 ccb->ccb_h.status = CAM_REQ_INVALID; 1201 xpt_done(ccb); 1202 break; 1203 } 1204} 1205 1206static void 1207ahbpoll(struct cam_sim *sim) 1208{ 1209 ahbintr(cam_sim_softc(sim)); 1210} 1211 1212static void 1213ahbtimeout(void *arg) 1214{ 1215 struct ecb *ecb; 1216 union ccb *ccb; 1217 struct ahb_softc *ahb; 1218 1219 ecb = (struct ecb *)arg; 1220 ccb = ecb->ccb; 1221 ahb = (struct ahb_softc *)ccb->ccb_h.ccb_ahb_ptr; 1222 mtx_assert(&ahb->lock, MA_OWNED); 1223 xpt_print_path(ccb->ccb_h.path); 1224 printf("ECB %p - timed out\n", (void *)ecb); 1225 1226 if ((ecb->state & ECB_ACTIVE) == 0) { 1227 xpt_print_path(ccb->ccb_h.path); 1228 printf("ECB %p - timed out ECB already completed\n", 1229 (void *)ecb); 1230 return; 1231 } 1232 /* 1233 * In order to simplify the recovery process, we ask the XPT 1234 * layer to halt the queue of new transactions and we traverse 1235 * the list of pending CCBs and remove their timeouts. This 1236 * means that the driver attempts to clear only one error 1237 * condition at a time. In general, timeouts that occur 1238 * close together are related anyway, so there is no benefit 1239 * in attempting to handle errors in parrallel. Timeouts will 1240 * be reinstated when the recovery process ends. 1241 */ 1242 if ((ecb->state & ECB_DEVICE_RESET) == 0) { 1243 struct ccb_hdr *ccb_h; 1244 1245 if ((ecb->state & ECB_RELEASE_SIMQ) == 0) { 1246 xpt_freeze_simq(ahb->sim, /*count*/1); 1247 ecb->state |= ECB_RELEASE_SIMQ; 1248 } 1249 1250 LIST_FOREACH(ccb_h, &ahb->pending_ccbs, sim_links.le) { 1251 struct ecb *pending_ecb; 1252 1253 pending_ecb = (struct ecb *)ccb_h->ccb_ecb_ptr; 1254 callout_stop(&pending_ecb->timer); 1255 } 1256 1257 /* Store for our interrupt handler */ 1258 ahb->immed_ecb = ecb; 1259 1260 /* 1261 * Send a Bus Device Reset message: 1262 * The target that is holding up the bus may not 1263 * be the same as the one that triggered this timeout 1264 * (different commands have different timeout lengths), 1265 * but we have no way of determining this from our 1266 * timeout handler. Our strategy here is to queue a 1267 * BDR message to the target of the timed out command. 1268 * If this fails, we'll get another timeout 2 seconds 1269 * later which will attempt a bus reset. 1270 */ 1271 xpt_print_path(ccb->ccb_h.path); 1272 printf("Queuing BDR\n"); 1273 ecb->state |= ECB_DEVICE_RESET; 1274 callout_reset(&ecb->timer, 2 * hz, ahbtimeout, ecb); 1275 1276 ahb->immed_cmd = IMMED_RESET; 1277 ahbqueuembox(ahb, IMMED_RESET, ATTN_IMMED|ccb->ccb_h.target_id); 1278 } else if ((ecb->state & ECB_SCSIBUS_RESET) != 0) { 1279 /* 1280 * Try a SCSI bus reset. We do this only if we 1281 * have already attempted to clear the condition with a BDR. 1282 */ 1283 xpt_print_path(ccb->ccb_h.path); 1284 printf("Attempting SCSI Bus reset\n"); 1285 ecb->state |= ECB_SCSIBUS_RESET; 1286 callout_reset(&ecb->timer, 2 * hz, ahbtimeout, ecb); 1287 ahb->immed_cmd = IMMED_RESET; 1288 ahbqueuembox(ahb, IMMED_RESET, ATTN_IMMED|ahb->scsi_id); 1289 } else { 1290 /* Bring out the hammer... */ 1291 ahbreset(ahb); 1292 1293 /* Simulate the reset complete interrupt */ 1294 ahbhandleimmed(ahb, 0, ahb->scsi_id|INTSTAT_IMMED_OK); 1295 } 1296} 1297 1298static device_method_t ahb_eisa_methods[] = { 1299 /* Device interface */ 1300 DEVMETHOD(device_probe, ahbprobe), 1301 DEVMETHOD(device_attach, ahbattach), 1302 1303 { 0, 0 } 1304}; 1305 1306static driver_t ahb_eisa_driver = { 1307 "ahb", 1308 ahb_eisa_methods, 1309 sizeof(struct ahb_softc), 1310}; 1311 1312static devclass_t ahb_devclass; 1313 1314DRIVER_MODULE(ahb, eisa, ahb_eisa_driver, ahb_devclass, 0, 0); 1315MODULE_DEPEND(ahb, eisa, 1, 1, 1); 1316MODULE_DEPEND(ahb, cam, 1, 1, 1); 1317