sys/arch/sgimips/hpc/wdsc.c

   1 /*      $NetBSD: wdsc.c,v 1.28 2009/02/12 06:24:45 rumble Exp $ */
   2
   3 /*
   4  * Copyright (c) 2001 Wayne Knowles
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Wayne Knowles
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *        This product includes software developed by the NetBSD
  21  *        Foundation, Inc. and its contributors.
  22  * 4. Neither the name of The NetBSD Foundation nor the names of its
  23  *    contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  36  * POSSIBILITY OF SUCH DAMAGE.
  37  */
  38
  39 #include <sys/cdefs.h>
  40 __KERNEL_RCSID(0, "$NetBSD: wdsc.c,v 1.28 2009/02/12 06:24:45 rumble Exp $");
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/kernel.h>
  45 #include <sys/device.h>
  46 #include <sys/buf.h>
  47
  48 #include <dev/scsipi/scsi_all.h>
  49 #include <dev/scsipi/scsipi_all.h>
  50 #include <dev/scsipi/scsiconf.h>
  51
  52 #include <machine/cpu.h>
  53 #include <machine/bus.h>
  54 #include <machine/autoconf.h>
  55 #include <machine/machtype.h>
  56 #include <machine/sysconf.h>
  57
  58 #include <sgimips/hpc/hpcvar.h>
  59 #include <sgimips/hpc/hpcreg.h>
  60 #include <sgimips/hpc/hpcdma.h>
  61
  62 #include <dev/ic/wd33c93reg.h>
  63 #include <dev/ic/wd33c93var.h>
  64
  65 #include <opt_kgdb.h>
  66 #include <sys/kgdb.h>
  67
  68 struct wdsc_softc {
  69         struct wd33c93_softc    sc_wd33c93; /* Must be first */
  70         struct evcnt            sc_intrcnt; /* Interrupt counter */
  71         bus_dma_tag_t           sc_dmat;
  72         bus_dmamap_t            sc_dmamap;
  73         int                     sc_flags;
  74 #define WDSC_DMA_ACTIVE                 0x1
  75 #define WDSC_DMA_MAPLOADED              0x2
  76         struct hpc_dma_softc    sc_hpcdma;
  77 };
  78
  79
  80 void    wdsc_attach     (device_t, device_t, void *);
  81 int     wdsc_match      (device_t, cfdata_t, void *);
  82
  83 CFATTACH_DECL_NEW(wdsc, sizeof(struct wdsc_softc),
  84     wdsc_match, wdsc_attach, NULL, NULL);
  85
  86 int     wdsc_dmasetup   (struct wd33c93_softc *, void ** ,size_t *,
  87                                 int, size_t *);
  88 int     wdsc_dmago      (struct wd33c93_softc *);
  89 void    wdsc_dmastop    (struct wd33c93_softc *);
  90 void    wdsc_reset      (struct wd33c93_softc *);
  91 int     wdsc_dmaintr    (void *);
  92 int     wdsc_scsiintr   (void *);
  93
  94 /*
  95  * Match for SCSI devices on the onboard and GIO32 adapter WD33C93 chips
  96  */
  97 int
  98 wdsc_match(device_t parent, cfdata_t cf, void *auxp)
  99 {
 100         struct hpc_attach_args *haa = auxp;
 101
 102         if (strcmp(haa->ha_name, cf->cf_name) == 0) {
 103                 vaddr_t reset, asr, reg;
 104
 105                 reset = MIPS_PHYS_TO_KSEG1(haa->ha_sh + haa->ha_dmaoff +
 106                     haa->hpc_regs->scsi0_ctl);
 107                 asr = MIPS_PHYS_TO_KSEG1(haa->ha_sh + haa->ha_devoff);
 108
 109                 /* XXX: hpc1 offset due to SGIMIPS_BUS_SPACE_HPC brain damage */
 110                 asr = (asr + 3) & ~0x3;
 111
 112                 if (platform.badaddr((void *)reset, sizeof(reset)))
 113                         return (0);
 114
 115                 *(volatile uint32_t *)reset = haa->hpc_regs->scsi_dmactl_reset;
 116                 delay(1000);
 117                 *(volatile uint32_t *)reset = 0x0;
 118
 119                 if (platform.badaddr((void *)asr, sizeof(asr)))
 120                         return (0);
 121
 122                 reg = *(volatile uint32_t *)asr;
 123                 if (haa->hpc_regs->revision == 3) {
 124                         if ((reg & 0xff) == SBIC_ASR_INT)
 125                                 return (1);
 126                 } else {
 127                         if (((reg >> 8) & 0xff) == SBIC_ASR_INT)
 128                                 return (1);
 129                 }
 130         }
 131
 132         return (0);
 133 }
 134
 135 /*
 136  * Attach the wdsc driver
 137  */
 138 void
 139 wdsc_attach(device_t parent, device_t self, void *aux)
 140 {
 141         struct wdsc_softc *wsc = device_private(self);
 142         struct wd33c93_softc *sc = &wsc->sc_wd33c93;
 143         struct hpc_attach_args *haa = aux;
 144         int err;
 145
 146         sc->sc_dev = self;
 147         sc->sc_regt = haa->ha_st;
 148         wsc->sc_dmat = haa->ha_dmat;
 149
 150         wsc->sc_hpcdma.hpc = haa->hpc_regs;
 151
 152         if ((err = bus_space_subregion(haa->ha_st, haa->ha_sh,
 153             haa->ha_devoff + 0, 4, &sc->sc_asr_regh)) != 0) {
 154                 printf(": unable to map asr reg, err=%d\n", err);
 155                 return;
 156         }
 157
 158         if ((err = bus_space_subregion(haa->ha_st, haa->ha_sh,
 159             haa->ha_devoff + 4,  4, &sc->sc_data_regh)) != 0) {
 160                 printf(": unable to map asr reg, err=%d\n", err);
 161                 return;
 162         }
 163
 164         if (bus_dmamap_create(wsc->sc_dmat,
 165                               wsc->sc_hpcdma.hpc->scsi_max_xfer,
 166                               wsc->sc_hpcdma.hpc->scsi_dma_segs,
 167                               wsc->sc_hpcdma.hpc->scsi_dma_segs_size,
 168                               wsc->sc_hpcdma.hpc->scsi_dma_segs_size,
 169                               BUS_DMA_WAITOK,
 170                               &wsc->sc_dmamap) != 0) {
 171                 printf(": failed to create dmamap\n");
 172                 return;
 173         }
 174
 175         sc->sc_dmasetup = wdsc_dmasetup;
 176         sc->sc_dmago    = wdsc_dmago;
 177         sc->sc_dmastop  = wdsc_dmastop;
 178         sc->sc_reset    = wdsc_reset;
 179
 180         sc->sc_adapter.adapt_request = wd33c93_scsi_request;
 181         sc->sc_adapter.adapt_minphys = minphys;
 182
 183         sc->sc_id = 0;                                  /* Host ID = 0 */
 184         sc->sc_clkfreq = 200;                           /* 20MHz */
 185         sc->sc_dmamode = SBIC_CTL_BURST_DMA;
 186
 187         evcnt_attach_dynamic(&wsc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
 188             device_xname(sc->sc_dev), "intr");
 189
 190         if ((cpu_intr_establish(haa->ha_irq, IPL_BIO,
 191              wdsc_scsiintr, wsc)) == NULL) {
 192                 printf(": unable to establish interrupt!\n");
 193                 return;
 194         }
 195
 196         hpcdma_init(haa, &wsc->sc_hpcdma, wsc->sc_hpcdma.hpc->scsi_dma_segs);
 197         wd33c93_attach(sc);
 198         return;
 199 }
 200
 201 /*
 202  * Prime the hardware for a DMA transfer
 203  *
 204  * Requires splbio() interrupts to be disabled by the caller
 205  */
 206 int
 207 wdsc_dmasetup(struct wd33c93_softc *sc, void **addr, size_t *len, int datain, size_t *dmasize)
 208 {
 209         struct wdsc_softc *wsc = (struct wdsc_softc *)sc;
 210         struct hpc_dma_softc *dsc = &wsc->sc_hpcdma;
 211         int count, err;
 212         void *vaddr;
 213
 214         KASSERT((wsc->sc_flags & WDSC_DMA_ACTIVE) == 0);
 215
 216         vaddr = *addr;
 217         count = dsc->sc_dlen = *len;
 218         if (count) {
 219                 KASSERT((wsc->sc_flags & WDSC_DMA_MAPLOADED) == 0);
 220
 221                 /* Build list of physical addresses for this transfer */
 222                 if ((err=bus_dmamap_load(wsc->sc_dmat, wsc->sc_dmamap,
 223                                 vaddr, count,
 224                                 NULL /* kernel address */,
 225                                 BUS_DMA_NOWAIT)) != 0)
 226                         panic("%s: bus_dmamap_load err=%d",
 227                             device_xname(sc->sc_dev), err);
 228
 229                 hpcdma_sglist_create(dsc, wsc->sc_dmamap);
 230                 wsc->sc_flags |= WDSC_DMA_MAPLOADED;
 231
 232                 if (datain) {
 233                         dsc->sc_dmacmd =
 234                             wsc->sc_hpcdma.hpc->scsi_dma_datain_cmd;
 235                         dsc->sc_flags |= HPCDMA_READ;
 236                 } else {
 237                         dsc->sc_dmacmd =
 238                             wsc->sc_hpcdma.hpc->scsi_dma_dataout_cmd;
 239                         dsc->sc_flags &= ~HPCDMA_READ;
 240                 }
 241         }
 242         return(count);
 243 }
 244
 245 /*
 246  * Prime the hardware for the next DMA transfer
 247  */
 248 int
 249 wdsc_dmago(struct wd33c93_softc *sc)
 250 {
 251         struct wdsc_softc *wsc = (struct wdsc_softc *)sc;
 252         struct hpc_dma_softc *dsc = &wsc->sc_hpcdma;
 253
 254         if (dsc->sc_dlen == 0)
 255                 return(0);
 256
 257         KASSERT((wsc->sc_flags & WDSC_DMA_ACTIVE) == 0);
 258         KASSERT((wsc->sc_flags & WDSC_DMA_MAPLOADED));
 259
 260         wsc->sc_flags |= WDSC_DMA_ACTIVE;
 261
 262         bus_dmamap_sync(wsc->sc_dmat, wsc->sc_dmamap, 0,
 263                         wsc->sc_dmamap->dm_mapsize,
 264                         BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
 265
 266         hpcdma_cntl(dsc, dsc->sc_dmacmd);       /* Thunderbirds are go! */
 267
 268         return(wsc->sc_dmamap->dm_mapsize);
 269 }
 270
 271 /*
 272  * Stop DMA and unload active DMA maps
 273  */
 274 void
 275 wdsc_dmastop(struct wd33c93_softc *sc)
 276 {
 277         struct wdsc_softc *wsc = (struct wdsc_softc *)sc;
 278         struct hpc_dma_softc *dsc = &wsc->sc_hpcdma;
 279
 280         if (wsc->sc_flags & WDSC_DMA_ACTIVE) {
 281                 if (dsc->sc_flags & HPCDMA_READ)
 282                         hpcdma_flush(dsc);
 283                 hpcdma_cntl(dsc, 0);    /* Stop DMA */
 284                 bus_dmamap_sync(wsc->sc_dmat, wsc->sc_dmamap, 0,
 285                     wsc->sc_dmamap->dm_mapsize,
 286                     BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
 287         }
 288         if (wsc->sc_flags & WDSC_DMA_MAPLOADED)
 289                 bus_dmamap_unload(wsc->sc_dmat, wsc->sc_dmamap);
 290         wsc->sc_flags &= ~(WDSC_DMA_ACTIVE | WDSC_DMA_MAPLOADED);
 291 }
 292
 293 /*
 294  * Reset the controller.
 295  */
 296 void
 297 wdsc_reset(struct wd33c93_softc *sc)
 298 {
 299         struct wdsc_softc *wsc = (struct wdsc_softc *)sc;
 300         struct hpc_dma_softc *dsc = &wsc->sc_hpcdma;
 301
 302         hpcdma_reset(dsc);
 303 }
 304
 305 /*
 306  * WD33c93 SCSI controller interrupt
 307  */
 308 int
 309 wdsc_scsiintr(void *arg)
 310 {
 311         struct wdsc_softc *wsc = arg;
 312         struct wd33c93_softc *sc = &wsc->sc_wd33c93;
 313         int found;
 314
 315         found = wd33c93_intr(sc);
 316         if (found)
 317                 wsc->sc_intrcnt.ev_count++;
 318         return(found);
 319 }