sys/dev/isp/isp_sbus.c

   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         bus_addr_t maddr;
 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
 427         if (!(imushp->error = error))
 428                 imushp->maddr = segs[0].ds_addr;
 429 }
 430
 431 static int
 432 isp_sbus_mbxdma(ispsoftc_t *isp)
 433 {
 434         caddr_t base;
 435         uint32_t len;
 436         int i, error;
 437         struct imush im;
 438
 439         /*
 440          * Already been here? If so, leave...
 441          */
 442         if (isp->isp_rquest) {
 443                 return (0);
 444         }
 445
 446         ISP_UNLOCK(isp);
 447
 448         len = sizeof (struct isp_pcmd) * isp->isp_maxcmds;
 449         isp->isp_osinfo.pcmd_pool = (struct isp_pcmd *)
 450             malloc(len, M_DEVBUF, M_WAITOK | M_ZERO);
 451         if (isp->isp_osinfo.pcmd_pool == NULL) {
 452                 isp_prt(isp, ISP_LOGERR, "cannot alloc pcmd pool");
 453                 ISP_LOCK(isp);
 454                 return (1);
 455         }
 456
 457         len = sizeof (isp_hdl_t *) * isp->isp_maxcmds;
 458         isp->isp_xflist = (isp_hdl_t *) malloc(len, M_DEVBUF, M_WAITOK | M_ZERO);
 459         if (isp->isp_xflist == NULL) {
 460                 isp_prt(isp, ISP_LOGERR, "cannot alloc xflist array");
 461                 ISP_LOCK(isp);
 462                 return (1);
 463         }
 464         for (len = 0; len < isp->isp_maxcmds - 1; len++) {
 465                 isp->isp_xflist[len].cmd = &isp->isp_xflist[len+1];
 466         }
 467         isp->isp_xffree = isp->isp_xflist;
 468         len = sizeof (bus_dmamap_t) * isp->isp_maxcmds;
 469
 470         if (isp_dma_tag_create(BUS_DMA_ROOTARG(ISP_SBD(isp)), 1,
 471             BUS_SPACE_MAXADDR_24BIT+1, BUS_SPACE_MAXADDR_32BIT,
 472             BUS_SPACE_MAXADDR_32BIT, NULL, NULL, BUS_SPACE_MAXSIZE_32BIT,
 473             ISP_NSEG_MAX, BUS_SPACE_MAXADDR_24BIT, 0, &isp->isp_osinfo.dmat)) {
 474                 isp_prt(isp, ISP_LOGERR, "could not create master dma tag");
 475                 goto bad;
 476         }
 477
 478         /*
 479          * Allocate and map the request queue.
 480          */
 481         len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
 482         if (isp_dma_tag_create(isp->isp_osinfo.dmat, QENTRY_LEN, BUS_SPACE_MAXADDR_24BIT+1,
 483             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
 484             len, 1, len, 0, &isp->isp_osinfo.reqdmat)) {
 485                 isp_prt(isp, ISP_LOGERR, "cannot create request DMA tag");
 486                 goto bad;
 487         }
 488         if (bus_dmamem_alloc(isp->isp_osinfo.reqdmat, (void **)&base,
 489             BUS_DMA_COHERENT, &isp->isp_osinfo.reqmap) != 0) {
 490                 isp_prt(isp, ISP_LOGERR, "cannot allocate request DMA memory");
 491                 bus_dma_tag_destroy(isp->isp_osinfo.reqdmat);
 492                 goto bad;
 493         }
 494         im.error = 0;
 495         if (bus_dmamap_load(isp->isp_osinfo.reqdmat, isp->isp_osinfo.reqmap,
 496             base, len, imc, &im, 0) || im.error) {
 497                 isp_prt(isp, ISP_LOGERR, "error loading request DMA map %d", im.error);
 498                 goto bad;
 499         }
 500         isp_prt(isp, ISP_LOGDEBUG0, "request area @ 0x%jx/0x%jx",
 501             (uintmax_t)im.maddr, (uintmax_t)len);
 502         isp->isp_rquest = base;
 503         isp->isp_rquest_dma = im.maddr;
 504
 505         /*
 506          * Allocate and map the result queue.
 507          */
 508         len = ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
 509         if (isp_dma_tag_create(isp->isp_osinfo.dmat, QENTRY_LEN, BUS_SPACE_MAXADDR_24BIT+1,
 510             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
 511             len, 1, len, 0, &isp->isp_osinfo.respdmat)) {
 512                 isp_prt(isp, ISP_LOGERR, "cannot create response DMA tag");
 513                 goto bad;
 514         }
 515         if (bus_dmamem_alloc(isp->isp_osinfo.respdmat, (void **)&base,
 516             BUS_DMA_COHERENT, &isp->isp_osinfo.respmap) != 0) {
 517                 isp_prt(isp, ISP_LOGERR, "cannot allocate response DMA memory");
 518                 bus_dma_tag_destroy(isp->isp_osinfo.respdmat);
 519                 goto bad;
 520         }
 521         im.error = 0;
 522         if (bus_dmamap_load(isp->isp_osinfo.respdmat, isp->isp_osinfo.respmap,
 523             base, len, imc, &im, 0) || im.error) {
 524                 isp_prt(isp, ISP_LOGERR, "error loading response DMA map %d", im.error);
 525                 goto bad;
 526         }
 527         isp_prt(isp, ISP_LOGDEBUG0, "response area @ 0x%jx/0x%jx",
 528             (uintmax_t)im.maddr, (uintmax_t)len);
 529         isp->isp_result = base;
 530         isp->isp_result_dma = im.maddr;
 531
 532         for (i = 0; i < isp->isp_maxcmds; i++) {
 533                 struct isp_pcmd *pcmd = &isp->isp_osinfo.pcmd_pool[i];
 534                 error = bus_dmamap_create(isp->isp_osinfo.dmat, 0, &pcmd->dmap);
 535                 if (error) {
 536                         isp_prt(isp, ISP_LOGERR,
 537                             "error %d creating per-cmd DMA maps", error);
 538                         while (--i >= 0) {
 539                                 bus_dmamap_destroy(isp->isp_osinfo.dmat,
 540                                     isp->isp_osinfo.pcmd_pool[i].dmap);
 541                         }
 542                         goto bad;
 543                 }
 544                 callout_init_mtx(&pcmd->wdog, &isp->isp_osinfo.lock, 0);
 545                 if (i == isp->isp_maxcmds-1) {
 546                         pcmd->next = NULL;
 547                 } else {
 548                         pcmd->next = &isp->isp_osinfo.pcmd_pool[i+1];
 549                 }
 550         }
 551         isp->isp_osinfo.pcmd_free = &isp->isp_osinfo.pcmd_pool[0];
 552         ISP_LOCK(isp);
 553         return (0);
 554
 555 bad:
 556         if (isp->isp_rquest_dma != 0) {
 557                 bus_dmamap_unload(isp->isp_osinfo.reqdmat,
 558                     isp->isp_osinfo.reqmap);
 559         }
 560         if (isp->isp_rquest != NULL) {
 561                 bus_dmamem_free(isp->isp_osinfo.reqdmat, isp->isp_rquest,
 562                     isp->isp_osinfo.reqmap);
 563                 bus_dma_tag_destroy(isp->isp_osinfo.reqdmat);
 564         }
 565         if (isp->isp_result_dma != 0) {
 566                 bus_dmamap_unload(isp->isp_osinfo.respdmat,
 567                     isp->isp_osinfo.respmap);
 568         }
 569         if (isp->isp_result != NULL) {
 570                 bus_dmamem_free(isp->isp_osinfo.respdmat, isp->isp_result,
 571                     isp->isp_osinfo.respmap);
 572                 bus_dma_tag_destroy(isp->isp_osinfo.respdmat);
 573         }
 574         free(isp->isp_xflist, M_DEVBUF);
 575         free(isp->isp_osinfo.pcmd_pool, M_DEVBUF);
 576         isp->isp_rquest = NULL;
 577         ISP_LOCK(isp);
 578         return (1);
 579 }
 580
 581 typedef struct {
 582         ispsoftc_t *isp;
 583         void *cmd_token;
 584         void *rq;       /* original request */
 585         int error;
 586         bus_size_t mapsize;
 587 } mush_t;
 588
 589 #define MUSHERR_NOQENTRIES      -2
 590
 591 static void dma2(void *, bus_dma_segment_t *, int, int);
 592
 593 static void
 594 dma2(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error)
 595 {
 596         mush_t *mp;
 597         ispsoftc_t *isp;
 598         struct ccb_scsiio *csio;
 599         isp_ddir_t ddir;
 600         ispreq_t *rq;
 601
 602         mp = (mush_t *) arg;
 603         if (error) {
 604                 mp->error = error;
 605                 return;
 606         }
 607         csio = mp->cmd_token;
 608         isp = mp->isp;
 609         rq = mp->rq;
 610         if (nseg) {
 611                 if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
 612                         bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, BUS_DMASYNC_PREREAD);
 613                         ddir = ISP_FROM_DEVICE;
 614                 } else if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT) {
 615                         bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, BUS_DMASYNC_PREWRITE);
 616                         ddir = ISP_TO_DEVICE;
 617                 } else {
 618                         ddir = ISP_NOXFR;
 619                 }
 620         } else {
 621                 dm_segs = NULL;
 622                 nseg = 0;
 623                 ddir = ISP_NOXFR;
 624         }
 625
 626         if (isp_send_cmd(isp, rq, dm_segs, nseg, XS_XFRLEN(csio), ddir, NULL) != CMD_QUEUED) {
 627                 mp->error = MUSHERR_NOQENTRIES;
 628         }
 629 }
 630
 631 static int
 632 isp_sbus_dmasetup(ispsoftc_t *isp, struct ccb_scsiio *csio, void *ff)
 633 {
 634         mush_t mush, *mp;
 635         void (*eptr)(void *, bus_dma_segment_t *, int, int);
 636         int error;
 637
 638         mp = &mush;
 639         mp->isp = isp;
 640         mp->cmd_token = csio;
 641         mp->rq = ff;
 642         mp->error = 0;
 643         mp->mapsize = 0;
 644
 645         eptr = dma2;
 646
 647         error = bus_dmamap_load_ccb(isp->isp_osinfo.dmat,
 648             PISP_PCMD(csio)->dmap, (union ccb *)csio, eptr, mp, 0);
 649         if (error == EINPROGRESS) {
 650                 bus_dmamap_unload(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap);
 651                 mp->error = EINVAL;
 652                 isp_prt(isp, ISP_LOGERR,
 653                     "deferred dma allocation not supported");
 654         } else if (error && mp->error == 0) {
 655 #ifdef  DIAGNOSTIC
 656                 isp_prt(isp, ISP_LOGERR, "error %d in dma mapping code", error);
 657 #endif
 658                 mp->error = error;
 659         }
 660         if (mp->error) {
 661                 int retval = CMD_COMPLETE;
 662                 if (mp->error == MUSHERR_NOQENTRIES) {
 663                         retval = CMD_EAGAIN;
 664                 } else if (mp->error == EFBIG) {
 665                         XS_SETERR(csio, CAM_REQ_TOO_BIG);
 666                 } else if (mp->error == EINVAL) {
 667                         XS_SETERR(csio, CAM_REQ_INVALID);
 668                 } else {
 669                         XS_SETERR(csio, CAM_UNREC_HBA_ERROR);
 670                 }
 671                 return (retval);
 672         }
 673         return (CMD_QUEUED);
 674 }
 675
 676 static void
 677 isp_sbus_reset0(ispsoftc_t *isp)
 678 {
 679         ISP_DISABLE_INTS(isp);
 680 }
 681
 682 static void
 683 isp_sbus_reset1(ispsoftc_t *isp)
 684 {
 685         ISP_ENABLE_INTS(isp);
 686 }
 687
 688 static void
 689 isp_sbus_dumpregs(ispsoftc_t *isp, const char *msg)
 690 {
 691         if (msg)
 692                 printf("%s: %s\n", device_get_nameunit(isp->isp_dev), msg);
 693         else
 694                 printf("%s:\n", device_get_nameunit(isp->isp_dev));
 695         printf("    biu_conf1=%x", ISP_READ(isp, BIU_CONF1));
 696         printf(" biu_icr=%x biu_isr=%x biu_sema=%x ", ISP_READ(isp, BIU_ICR),
 697             ISP_READ(isp, BIU_ISR), ISP_READ(isp, BIU_SEMA));
 698         printf("risc_hccr=%x\n", ISP_READ(isp, HCCR));
 699
 700
 701         ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
 702         printf("    cdma_conf=%x cdma_sts=%x cdma_fifostat=%x\n",
 703                 ISP_READ(isp, CDMA_CONF), ISP_READ(isp, CDMA_STATUS),
 704                 ISP_READ(isp, CDMA_FIFO_STS));
 705         printf("    ddma_conf=%x ddma_sts=%x ddma_fifostat=%x\n",
 706                 ISP_READ(isp, DDMA_CONF), ISP_READ(isp, DDMA_STATUS),
 707                 ISP_READ(isp, DDMA_FIFO_STS));
 708         printf("    sxp_int=%x sxp_gross=%x sxp(scsi_ctrl)=%x\n",
 709                 ISP_READ(isp, SXP_INTERRUPT),
 710                 ISP_READ(isp, SXP_GROSS_ERR),
 711                 ISP_READ(isp, SXP_PINS_CTRL));
 712         ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
 713         printf("    mbox regs: %x %x %x %x %x\n",
 714             ISP_READ(isp, OUTMAILBOX0), ISP_READ(isp, OUTMAILBOX1),
 715             ISP_READ(isp, OUTMAILBOX2), ISP_READ(isp, OUTMAILBOX3),
 716             ISP_READ(isp, OUTMAILBOX4));
 717 }