1 /*- 2 * Copyright (c) 1997-2006 by Matthew Jacob 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice immediately at the beginning of the file, without modification, 10 * this list of conditions, and the following disclaimer. 11 * 2. The name of the author may not be used to endorse or promote products 12 * derived from this software without specific prior written permission. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 18 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 /* 27 * SBus specific probe and attach routines for Qlogic ISP SCSI adapters. 28 * FreeBSD Version. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/linker.h> 37 #include <sys/firmware.h> 38 #include <sys/bus.h> 39 #include <sys/kernel.h> 40 #include <sys/module.h> 41 #include <sys/resource.h> 42 43 #include <dev/ofw/ofw_bus.h> 44 #include <dev/ofw/openfirm.h> 45 46 #include <machine/bus.h> 47 #include <machine/ofw_machdep.h> 48 #include <machine/resource.h> 49 #include <sys/rman.h> 50 #include <sparc64/sbus/sbusvar.h> 51 52 #include <dev/isp/isp_freebsd.h> 53 54 static uint32_t isp_sbus_rd_reg(ispsoftc_t *, int); 55 static void isp_sbus_wr_reg(ispsoftc_t *, int, uint32_t); 56 static int isp_sbus_rd_isr(ispsoftc_t *, uint16_t *, uint16_t *, uint16_t *); 57 static int isp_sbus_mbxdma(ispsoftc_t *); 58 static int isp_sbus_dmasetup(ispsoftc_t *, XS_T *, void *); 59 60 61 static void isp_sbus_reset0(ispsoftc_t *); 62 static void isp_sbus_reset1(ispsoftc_t *); 63 static void isp_sbus_dumpregs(ispsoftc_t *, const char *); 64 65 static struct ispmdvec mdvec = { 66 isp_sbus_rd_isr, 67 isp_sbus_rd_reg, 68 isp_sbus_wr_reg, 69 isp_sbus_mbxdma, 70 isp_sbus_dmasetup, 71 isp_common_dmateardown, 72 isp_sbus_reset0, 73 isp_sbus_reset1, 74 isp_sbus_dumpregs, 75 NULL, 76 BIU_BURST_ENABLE|BIU_PCI_CONF1_FIFO_64 77 }; 78 79 static int isp_sbus_probe (device_t); 80 static int isp_sbus_attach (device_t); 81 static int isp_sbus_detach (device_t); 82 83 84 #define ISP_SBD(isp) ((struct isp_sbussoftc *)isp)->sbus_dev 85 struct isp_sbussoftc { 86 ispsoftc_t sbus_isp; 87 device_t sbus_dev; 88 struct resource * regs; 89 void * irq; 90 int iqd; 91 int rgd; 92 void * ih; 93 int16_t sbus_poff[_NREG_BLKS]; 94 sdparam sbus_param; 95 struct isp_spi sbus_spi; 96 struct ispmdvec sbus_mdvec; 97 }; 98 99 100 static device_method_t isp_sbus_methods[] = { 101 /* Device interface */ 102 DEVMETHOD(device_probe, isp_sbus_probe), 103 DEVMETHOD(device_attach, isp_sbus_attach), 104 DEVMETHOD(device_detach, isp_sbus_detach), 105 { 0, 0 } 106 }; 107 108 static driver_t isp_sbus_driver = { 109 "isp", isp_sbus_methods, sizeof (struct isp_sbussoftc) 110 }; 111 static devclass_t isp_devclass; 112 DRIVER_MODULE(isp, sbus, isp_sbus_driver, isp_devclass, 0, 0); 113 MODULE_DEPEND(isp, cam, 1, 1, 1); 114 MODULE_DEPEND(isp, firmware, 1, 1, 1); 115 116 static int 117 isp_sbus_probe(device_t dev) 118 { 119 int found = 0; 120 const char *name = ofw_bus_get_name(dev); 121 if (strcmp(name, "SUNW,isp") == 0 || 122 strcmp(name, "QLGC,isp") == 0 || 123 strcmp(name, "ptisp") == 0 || 124 strcmp(name, "PTI,ptisp") == 0) { 125 found++; 126 } 127 if (!found) 128 return (ENXIO); 129 130 if (isp_announced == 0 && bootverbose) { 131 printf("Qlogic ISP Driver, FreeBSD Version %d.%d, " 132 "Core Version %d.%d\n", 133 ISP_PLATFORM_VERSION_MAJOR, ISP_PLATFORM_VERSION_MINOR, 134 ISP_CORE_VERSION_MAJOR, ISP_CORE_VERSION_MINOR); 135 isp_announced++; 136 } 137 return (0); 138 } 139 140 static int 141 isp_sbus_attach(device_t dev) 142 { 143 int tval, isp_debug, role, ispburst, default_id; 144 struct isp_sbussoftc *sbs; 145 ispsoftc_t *isp = NULL; 146 int locksetup = 0; 147 int ints_setup = 0; 148 149 sbs = device_get_softc(dev); 150 if (sbs == NULL) { 151 device_printf(dev, "cannot get softc\n"); 152 return (ENOMEM); 153 } 154 155 sbs->sbus_dev = dev; 156 sbs->sbus_mdvec = mdvec; 157 158 role = 0; 159 if (resource_int_value(device_get_name(dev), device_get_unit(dev), 160 "role", &role) == 0 && 161 ((role & ~(ISP_ROLE_INITIATOR|ISP_ROLE_TARGET)) == 0)) { 162 device_printf(dev, "setting role to 0x%x\n", role); 163 } else { 164 role = ISP_DEFAULT_ROLES; 165 } 166 167 sbs->irq = sbs->regs = NULL; 168 sbs->rgd = sbs->iqd = 0; 169 170 sbs->regs = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sbs->rgd, 171 RF_ACTIVE); 172 if (sbs->regs == NULL) { 173 device_printf(dev, "unable to map registers\n"); 174 goto bad; 175 } 176 177 sbs->sbus_poff[BIU_BLOCK >> _BLK_REG_SHFT] = BIU_REGS_OFF; 178 sbs->sbus_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = SBUS_MBOX_REGS_OFF; 179 sbs->sbus_poff[SXP_BLOCK >> _BLK_REG_SHFT] = SBUS_SXP_REGS_OFF; 180 sbs->sbus_poff[RISC_BLOCK >> _BLK_REG_SHFT] = SBUS_RISC_REGS_OFF; 181 sbs->sbus_poff[DMA_BLOCK >> _BLK_REG_SHFT] = DMA_REGS_OFF; 182 isp = &sbs->sbus_isp; 183 isp->isp_regs = sbs->regs; 184 isp->isp_mdvec = &sbs->sbus_mdvec; 185 isp->isp_bustype = ISP_BT_SBUS; 186 isp->isp_type = ISP_HA_SCSI_UNKNOWN; 187 isp->isp_param = &sbs->sbus_param; 188 isp->isp_osinfo.pc.ptr = &sbs->sbus_spi; 189 isp->isp_revision = 0; /* XXX */ 190 isp->isp_dev = dev; 191 isp->isp_nchan = 1; 192 if (IS_FC(isp)) 193 ISP_FC_PC(isp, 0)->def_role = role; 194 195 /* 196 * Get the clock frequency and convert it from HZ to MHz, 197 * rounding up. This defaults to 25MHz if there isn't a 198 * device specific one in the OFW device tree. 199 */ 200 sbs->sbus_mdvec.dv_clock = (sbus_get_clockfreq(dev) + 500000)/1000000; 201 202 /* 203 * Now figure out what the proper burst sizes, etc., to use. 204 * Unfortunately, there is no ddi_dma_burstsizes here which 205 * walks up the tree finding the limiting burst size node (if 206 * any). We just use what's here for isp. 207 */ 208 ispburst = sbus_get_burstsz(dev); 209 if (ispburst == 0) { 210 ispburst = SBUS_BURST_32 - 1; 211 } 212 sbs->sbus_mdvec.dv_conf1 = 0; 213 if (ispburst & (1 << 5)) { 214 sbs->sbus_mdvec.dv_conf1 = BIU_SBUS_CONF1_FIFO_32; 215 } else if (ispburst & (1 << 4)) { 216 sbs->sbus_mdvec.dv_conf1 = BIU_SBUS_CONF1_FIFO_16; 217 } else if (ispburst & (1 << 3)) { 218 sbs->sbus_mdvec.dv_conf1 = 219 BIU_SBUS_CONF1_BURST8 | BIU_SBUS_CONF1_FIFO_8; 220 } 221 if (sbs->sbus_mdvec.dv_conf1) { 222 sbs->sbus_mdvec.dv_conf1 |= BIU_BURST_ENABLE; 223 } 224 225 /* 226 * We don't trust NVRAM on SBus cards 227 */ 228 isp->isp_confopts |= ISP_CFG_NONVRAM; 229 230 /* 231 * Mark things if we're a PTI SBus adapter. 232 */ 233 if (strcmp("PTI,ptisp", ofw_bus_get_name(dev)) == 0 || 234 strcmp("ptisp", ofw_bus_get_name(dev)) == 0) { 235 SDPARAM(isp, 0)->isp_ptisp = 1; 236 } 237 238 isp->isp_osinfo.fw = firmware_get("isp_1000"); 239 if (isp->isp_osinfo.fw) { 240 union { 241 const void *cp; 242 uint16_t *sp; 243 } stupid; 244 stupid.cp = isp->isp_osinfo.fw->data; 245 isp->isp_mdvec->dv_ispfw = stupid.sp; 246 } 247 248 tval = 0; 249 if (resource_int_value(device_get_name(dev), device_get_unit(dev), 250 "fwload_disable", &tval) == 0 && tval != 0) { 251 isp->isp_confopts |= ISP_CFG_NORELOAD; 252 } 253 254 default_id = -1; 255 if (resource_int_value(device_get_name(dev), device_get_unit(dev), 256 "iid", &tval) == 0) { 257 default_id = tval; 258 isp->isp_confopts |= ISP_CFG_OWNLOOPID; 259 } 260 if (default_id == -1) { 261 default_id = OF_getscsinitid(dev); 262 } 263 ISP_SPI_PC(isp, 0)->iid = default_id; 264 265 isp_debug = 0; 266 (void) resource_int_value(device_get_name(dev), device_get_unit(dev), 267 "debug", &isp_debug); 268 269 /* Make sure the lock is set up. */ 270 mtx_init(&isp->isp_osinfo.lock, "isp", NULL, MTX_DEF); 271 locksetup++; 272 273 sbs->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sbs->iqd, 274 RF_ACTIVE | RF_SHAREABLE); 275 if (sbs->irq == NULL) { 276 device_printf(dev, "could not allocate interrupt\n"); 277 goto bad; 278 } 279 280 if (isp_setup_intr(dev, sbs->irq, ISP_IFLAGS, NULL, isp_platform_intr, 281 isp, &sbs->ih)) { 282 device_printf(dev, "could not setup interrupt\n"); 283 goto bad; 284 } 285 ints_setup++; 286 287 /* 288 * Set up logging levels. 289 */ 290 if (isp_debug) { 291 isp->isp_dblev = isp_debug; 292 } else { 293 isp->isp_dblev = ISP_LOGWARN|ISP_LOGERR; 294 } 295 if (bootverbose) { 296 isp->isp_dblev |= ISP_LOGCONFIG|ISP_LOGINFO; 297 } 298 299 /* 300 * Make sure we're in reset state. 301 */ 302 ISP_LOCK(isp); 303 if (isp_reinit(isp, 1) != 0) { 304 isp_uninit(isp); 305 ISP_UNLOCK(isp); 306 goto bad; 307 } 308 ISP_UNLOCK(isp); 309 if (isp_attach(isp)) { 310 ISP_LOCK(isp); 311 isp_uninit(isp); 312 ISP_UNLOCK(isp); 313 goto bad; 314 } 315 return (0); 316 317 bad: 318 319 if (sbs && ints_setup) { 320 (void) bus_teardown_intr(dev, sbs->irq, sbs->ih); 321 } 322 323 if (sbs && sbs->irq) { 324 bus_release_resource(dev, SYS_RES_IRQ, sbs->iqd, sbs->irq); 325 } 326 327 if (locksetup && isp) { 328 mtx_destroy(&isp->isp_osinfo.lock); 329 } 330 331 if (sbs->regs) { 332 (void) bus_release_resource(dev, SYS_RES_MEMORY, sbs->rgd, 333 sbs->regs); 334 } 335 return (ENXIO); 336 } 337 338 static int 339 isp_sbus_detach(device_t dev) 340 { 341 struct isp_sbussoftc *sbs; 342 ispsoftc_t *isp; 343 int status; 344 345 sbs = device_get_softc(dev); 346 if (sbs == NULL) { 347 return (ENXIO); 348 } 349 isp = (ispsoftc_t *) sbs; 350 status = isp_detach(isp); 351 if (status) 352 return (status); 353 ISP_LOCK(isp); 354 isp_uninit(isp); 355 if (sbs->ih) { 356 (void) bus_teardown_intr(dev, sbs->irq, sbs->ih); 357 } 358 ISP_UNLOCK(isp); 359 mtx_destroy(&isp->isp_osinfo.lock); 360 (void) bus_release_resource(dev, SYS_RES_IRQ, sbs->iqd, sbs->irq); 361 (void) bus_release_resource(dev, SYS_RES_MEMORY, sbs->rgd, sbs->regs); 362 return (0); 363 } 364 365 #define IspVirt2Off(a, x) \ 366 (((struct isp_sbussoftc *)a)->sbus_poff[((x) & _BLK_REG_MASK) >> \ 367 _BLK_REG_SHFT] + ((x) & 0xff)) 368 369 #define BXR2(isp, off) bus_read_2((isp)->isp_regs, (off)) 370 371 static int 372 isp_sbus_rd_isr(ispsoftc_t *isp, uint16_t *isrp, uint16_t *semap, uint16_t *info) 373 { 374 uint16_t isr, sema; 375 376 isr = BXR2(isp, IspVirt2Off(isp, BIU_ISR)); 377 sema = BXR2(isp, IspVirt2Off(isp, BIU_SEMA)); 378 isp_prt(isp, ISP_LOGDEBUG3, "ISR 0x%x SEMA 0x%x", isr, sema); 379 isr &= INT_PENDING_MASK(isp); 380 sema &= BIU_SEMA_LOCK; 381 if (isr == 0 && sema == 0) { 382 return (0); 383 } 384 *isrp = isr; 385 if ((*semap = sema) != 0) 386 *info = BXR2(isp, IspVirt2Off(isp, OUTMAILBOX0)); 387 return (1); 388 } 389 390 static uint32_t 391 isp_sbus_rd_reg(ispsoftc_t *isp, int regoff) 392 { 393 uint16_t rval; 394 struct isp_sbussoftc *sbs = (struct isp_sbussoftc *) isp; 395 int offset = sbs->sbus_poff[(regoff & _BLK_REG_MASK) >> _BLK_REG_SHFT]; 396 offset += (regoff & 0xff); 397 rval = BXR2(isp, offset); 398 isp_prt(isp, ISP_LOGDEBUG3, 399 "isp_sbus_rd_reg(off %x) = %x", regoff, rval); 400 return (rval); 401 } 402 403 static void 404 isp_sbus_wr_reg(ispsoftc_t *isp, int regoff, uint32_t val) 405 { 406 struct isp_sbussoftc *sbs = (struct isp_sbussoftc *) isp; 407 int offset = sbs->sbus_poff[(regoff & _BLK_REG_MASK) >> _BLK_REG_SHFT]; 408 offset += (regoff & 0xff); 409 isp_prt(isp, ISP_LOGDEBUG3, 410 "isp_sbus_wr_reg(off %x) = %x", regoff, val); 411 bus_write_2(isp->isp_regs, offset, val); 412 MEMORYBARRIER(isp, SYNC_REG, offset, 2, -1); 413 } 414 415 struct imush { 416 ispsoftc_t *isp; 417 int error; 418 }; 419 420 static void imc(void *, bus_dma_segment_t *, int, int); 421 422 static void 423 imc(void *arg, bus_dma_segment_t *segs, int nseg, int error) 424 { 425 struct imush *imushp = (struct imush *) arg; 426 if (error) { 427 imushp->error = error; 428 } else { 429 ispsoftc_t *isp =imushp->isp; 430 bus_addr_t addr = segs->ds_addr; 431 432 isp->isp_rquest_dma = addr; 433 addr += ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)); 434 isp->isp_result_dma = addr; 435 } 436 } 437 438 static int 439 isp_sbus_mbxdma(ispsoftc_t *isp) 440 { 441 caddr_t base; 442 uint32_t len; 443 int i, error; 444 struct imush im; 445 446 /* 447 * Already been here? If so, leave... 448 */ 449 if (isp->isp_rquest) { 450 return (0); 451 } 452 453 ISP_UNLOCK(isp); 454 455 len = sizeof (struct isp_pcmd) * isp->isp_maxcmds; 456 isp->isp_osinfo.pcmd_pool = (struct isp_pcmd *) 457 malloc(len, M_DEVBUF, M_WAITOK | M_ZERO); 458 if (isp->isp_osinfo.pcmd_pool == NULL) { 459 isp_prt(isp, ISP_LOGERR, "cannot alloc pcmd pool"); 460 ISP_LOCK(isp); 461 return (1); 462 } 463 464 len = sizeof (isp_hdl_t *) * isp->isp_maxcmds; 465 isp->isp_xflist = (isp_hdl_t *) malloc(len, M_DEVBUF, M_WAITOK | M_ZERO); 466 if (isp->isp_xflist == NULL) { 467 isp_prt(isp, ISP_LOGERR, "cannot alloc xflist array"); 468 ISP_LOCK(isp); 469 return (1); 470 } 471 for (len = 0; len < isp->isp_maxcmds - 1; len++) { 472 isp->isp_xflist[len].cmd = &isp->isp_xflist[len+1]; 473 } 474 isp->isp_xffree = isp->isp_xflist; 475 len = sizeof (bus_dmamap_t) * isp->isp_maxcmds; 476 477 if (isp_dma_tag_create(BUS_DMA_ROOTARG(ISP_SBD(isp)), 1, 478 BUS_SPACE_MAXADDR_24BIT+1, BUS_SPACE_MAXADDR_32BIT, 479 BUS_SPACE_MAXADDR_32BIT, NULL, NULL, BUS_SPACE_MAXSIZE_32BIT, 480 ISP_NSEG_MAX, BUS_SPACE_MAXADDR_24BIT, 0, &isp->isp_osinfo.dmat)) { 481 isp_prt(isp, ISP_LOGERR, "could not create master dma tag"); 482 free(isp->isp_osinfo.pcmd_pool, M_DEVBUF); 483 free(isp->isp_xflist, M_DEVBUF); 484 ISP_LOCK(isp); 485 return(1); 486 } 487 488 /* 489 * Allocate and map the request, result queues, plus FC scratch area. 490 */ 491 len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)); 492 len += ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp)); 493 494 if (isp_dma_tag_create(isp->isp_osinfo.dmat, QENTRY_LEN, 495 BUS_SPACE_MAXADDR_24BIT+1, BUS_SPACE_MAXADDR_32BIT, 496 BUS_SPACE_MAXADDR_32BIT, NULL, NULL, len, 1, 497 BUS_SPACE_MAXADDR_24BIT, 0, &isp->isp_osinfo.cdmat)) { 498 isp_prt(isp, ISP_LOGERR, 499 "cannot create a dma tag for control spaces"); 500 free(isp->isp_osinfo.pcmd_pool, M_DEVBUF); 501 free(isp->isp_xflist, M_DEVBUF); 502 ISP_LOCK(isp); 503 return (1); 504 } 505 506 if (bus_dmamem_alloc(isp->isp_osinfo.cdmat, (void **)&base, BUS_DMA_NOWAIT | BUS_DMA_COHERENT, 507 &isp->isp_osinfo.cdmap) != 0) { 508 isp_prt(isp, ISP_LOGERR, 509 "cannot allocate %d bytes of CCB memory", len); 510 bus_dma_tag_destroy(isp->isp_osinfo.cdmat); 511 free(isp->isp_osinfo.pcmd_pool, M_DEVBUF); 512 free(isp->isp_xflist, M_DEVBUF); 513 ISP_LOCK(isp); 514 return (1); 515 } 516 517 for (i = 0; i < isp->isp_maxcmds; i++) { 518 struct isp_pcmd *pcmd = &isp->isp_osinfo.pcmd_pool[i]; 519 error = bus_dmamap_create(isp->isp_osinfo.dmat, 0, &pcmd->dmap); 520 if (error) { 521 isp_prt(isp, ISP_LOGERR, 522 "error %d creating per-cmd DMA maps", error); 523 while (--i >= 0) { 524 bus_dmamap_destroy(isp->isp_osinfo.dmat, 525 isp->isp_osinfo.pcmd_pool[i].dmap); 526 } 527 goto bad; 528 } 529 callout_init_mtx(&pcmd->wdog, &isp->isp_osinfo.lock, 0); 530 if (i == isp->isp_maxcmds-1) { 531 pcmd->next = NULL; 532 } else { 533 pcmd->next = &isp->isp_osinfo.pcmd_pool[i+1]; 534 } 535 } 536 isp->isp_osinfo.pcmd_free = &isp->isp_osinfo.pcmd_pool[0]; 537 538 im.isp = isp; 539 im.error = 0; 540 bus_dmamap_load(isp->isp_osinfo.cdmat, isp->isp_osinfo.cdmap, base, len, imc, &im, 0); 541 if (im.error) { 542 isp_prt(isp, ISP_LOGERR, 543 "error %d loading dma map for control areas", im.error); 544 goto bad; 545 } 546 547 isp->isp_rquest = base; 548 base += ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)); 549 isp->isp_result = base; 550 ISP_LOCK(isp); 551 return (0); 552 553 bad: 554 bus_dmamem_free(isp->isp_osinfo.cdmat, base, isp->isp_osinfo.cdmap); 555 bus_dma_tag_destroy(isp->isp_osinfo.cdmat); 556 free(isp->isp_xflist, M_DEVBUF); 557 free(isp->isp_osinfo.pcmd_pool, M_DEVBUF); 558 isp->isp_rquest = NULL; 559 ISP_LOCK(isp); 560 return (1); 561 } 562 563 typedef struct { 564 ispsoftc_t *isp; 565 void *cmd_token; 566 void *rq; /* original request */ 567 int error; 568 bus_size_t mapsize; 569 } mush_t; 570 571 #define MUSHERR_NOQENTRIES -2 572 573 static void dma2(void *, bus_dma_segment_t *, int, int); 574 575 static void 576 dma2(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error) 577 { 578 mush_t *mp; 579 ispsoftc_t *isp; 580 struct ccb_scsiio *csio; 581 isp_ddir_t ddir; 582 ispreq_t *rq; 583 584 mp = (mush_t *) arg; 585 if (error) { 586 mp->error = error; 587 return; 588 } 589 csio = mp->cmd_token; 590 isp = mp->isp; 591 rq = mp->rq; 592 if (nseg) { 593 if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) { 594 bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, BUS_DMASYNC_PREREAD); 595 ddir = ISP_FROM_DEVICE; 596 } else if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT) { 597 bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, BUS_DMASYNC_PREWRITE); 598 ddir = ISP_TO_DEVICE; 599 } else { 600 ddir = ISP_NOXFR; 601 } 602 } else { 603 dm_segs = NULL; 604 nseg = 0; 605 ddir = ISP_NOXFR; 606 } 607 608 if (isp_send_cmd(isp, rq, dm_segs, nseg, XS_XFRLEN(csio), ddir, NULL) != CMD_QUEUED) { 609 mp->error = MUSHERR_NOQENTRIES; 610 } 611 } 612 613 static int 614 isp_sbus_dmasetup(ispsoftc_t *isp, struct ccb_scsiio *csio, void *ff) 615 { 616 mush_t mush, *mp; 617 void (*eptr)(void *, bus_dma_segment_t *, int, int); 618 int error; 619 620 mp = &mush; 621 mp->isp = isp; 622 mp->cmd_token = csio; 623 mp->rq = ff; 624 mp->error = 0; 625 mp->mapsize = 0; 626 627 eptr = dma2; 628 629 error = bus_dmamap_load_ccb(isp->isp_osinfo.dmat, 630 PISP_PCMD(csio)->dmap, (union ccb *)csio, eptr, mp, 0); 631 if (error == EINPROGRESS) { 632 bus_dmamap_unload(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap); 633 mp->error = EINVAL; 634 isp_prt(isp, ISP_LOGERR, 635 "deferred dma allocation not supported"); 636 } else if (error && mp->error == 0) { 637 #ifdef DIAGNOSTIC 638 isp_prt(isp, ISP_LOGERR, "error %d in dma mapping code", error); 639 #endif 640 mp->error = error; 641 } 642 if (mp->error) { 643 int retval = CMD_COMPLETE; 644 if (mp->error == MUSHERR_NOQENTRIES) { 645 retval = CMD_EAGAIN; 646 } else if (mp->error == EFBIG) { 647 XS_SETERR(csio, CAM_REQ_TOO_BIG); 648 } else if (mp->error == EINVAL) { 649 XS_SETERR(csio, CAM_REQ_INVALID); 650 } else { 651 XS_SETERR(csio, CAM_UNREC_HBA_ERROR); 652 } 653 return (retval); 654 } 655 return (CMD_QUEUED); 656 } 657 658 static void 659 isp_sbus_reset0(ispsoftc_t *isp) 660 { 661 ISP_DISABLE_INTS(isp); 662 } 663 664 static void 665 isp_sbus_reset1(ispsoftc_t *isp) 666 { 667 ISP_ENABLE_INTS(isp); 668 } 669 670 static void 671 isp_sbus_dumpregs(ispsoftc_t *isp, const char *msg) 672 { 673 if (msg) 674 printf("%s: %s\n", device_get_nameunit(isp->isp_dev), msg); 675 else 676 printf("%s:\n", device_get_nameunit(isp->isp_dev)); 677 printf(" biu_conf1=%x", ISP_READ(isp, BIU_CONF1)); 678 printf(" biu_icr=%x biu_isr=%x biu_sema=%x ", ISP_READ(isp, BIU_ICR), 679 ISP_READ(isp, BIU_ISR), ISP_READ(isp, BIU_SEMA)); 680 printf("risc_hccr=%x\n", ISP_READ(isp, HCCR)); 681 682 683 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE); 684 printf(" cdma_conf=%x cdma_sts=%x cdma_fifostat=%x\n", 685 ISP_READ(isp, CDMA_CONF), ISP_READ(isp, CDMA_STATUS), 686 ISP_READ(isp, CDMA_FIFO_STS)); 687 printf(" ddma_conf=%x ddma_sts=%x ddma_fifostat=%x\n", 688 ISP_READ(isp, DDMA_CONF), ISP_READ(isp, DDMA_STATUS), 689 ISP_READ(isp, DDMA_FIFO_STS)); 690 printf(" sxp_int=%x sxp_gross=%x sxp(scsi_ctrl)=%x\n", 691 ISP_READ(isp, SXP_INTERRUPT), 692 ISP_READ(isp, SXP_GROSS_ERR), 693 ISP_READ(isp, SXP_PINS_CTRL)); 694 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); 695 printf(" mbox regs: %x %x %x %x %x\n", 696 ISP_READ(isp, OUTMAILBOX0), ISP_READ(isp, OUTMAILBOX1), 697 ISP_READ(isp, OUTMAILBOX2), ISP_READ(isp, OUTMAILBOX3), 698 ISP_READ(isp, OUTMAILBOX4)); 699 } 700