Home | History | Annotate | Line # | Download | only in hpc
wdsc.c revision 1.2
      1 /*	$NetBSD: wdsc.c,v 1.2 2001/11/10 07:32:43 wdk 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 /*
     40  * TODO:
     41  *    Support for 2nd SCSI controller
     42  */
     43 
     44 #include <sys/param.h>
     45 #include <sys/systm.h>
     46 #include <sys/kernel.h>
     47 #include <sys/device.h>
     48 #include <sys/buf.h>
     49 
     50 #include <dev/scsipi/scsi_all.h>
     51 #include <dev/scsipi/scsipi_all.h>
     52 #include <dev/scsipi/scsiconf.h>
     53 
     54 #include <machine/cpu.h>
     55 #include <machine/bus.h>
     56 #include <machine/autoconf.h>
     57 
     58 #include <sgimips/hpc/hpcvar.h>
     59 #include <sgimips/hpc/hpcreg.h>
     60 #include <sgimips/hpc/hpcdma.h>
     61 
     62 #include <sgimips/hpc/sbicreg.h>
     63 #include <sgimips/hpc/sbicvar.h>
     64 
     65 #include <opt_kgdb.h>
     66 #include <sys/kgdb.h>
     67 
     68 struct wdsc_softc {
     69 	struct sbic_softc	sc_sbic; /* 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 __P((struct device *, struct device *, void *));
     81 int     wdsc_match  __P((struct device *, struct cfdata *, void *));
     82 
     83 struct cfattach wdsc_ca = {
     84 	sizeof(struct wdsc_softc), wdsc_match, wdsc_attach
     85 };
     86 
     87 extern struct cfdriver wdsc_cd;
     88 
     89 int     wdsc_dmasetup   __P((struct sbic_softc *, caddr_t *,size_t *,
     90 				int, size_t *));
     91 int     wdsc_dmago      __P((struct sbic_softc *));
     92 void    wdsc_dmastop    __P((struct sbic_softc *));
     93 int     wdsc_dmaintr    __P((void *));
     94 int     wdsc_scsiintr   __P((void *));
     95 
     96 #define MAX_SCSI_XFER   (512*1024)
     97 #define MAX_SEG_SZ	8192
     98 #define	MAX_DMA_SZ	MAX_SCSI_XFER
     99 #define	DMA_SEGS	(MAX_DMA_SZ/MAX_SEG_SZ)
    100 
    101 /*
    102  * Match for SCSI devices on the onboard WD33C93 chip
    103  */
    104 int
    105 wdsc_match(pdp, cf, auxp)
    106 	struct device *pdp;
    107 	struct cfdata *cf;
    108 	void *auxp;
    109 {
    110 	struct hpc_attach_args *haa = auxp;
    111 
    112 	if (strcmp(haa->ha_name, wdsc_cd.cd_name))
    113 		return (0);
    114 	return (1);
    115 }
    116 
    117 /*
    118  * Attach the wdsc driver
    119  */
    120 void
    121 wdsc_attach(pdp, dp, auxp)
    122 	struct device *pdp, *dp;
    123 	void *auxp;
    124 {
    125 	struct sbic_softc *sc = (void *)dp;
    126 	struct wdsc_softc *wsc = (void *)dp;
    127 	struct hpc_attach_args *haa = auxp;
    128 	int err;
    129 
    130 	sc->sc_regt = haa->ha_iot;
    131 	wsc->sc_dmat = haa->ha_dmat;
    132 
    133 	if ((err = bus_space_subregion(haa->ha_iot, haa->ha_ioh,
    134 					HPC_SCSI0_DEVREGS,
    135 	     				HPC_SCSI0_DEVREGS_SIZE,
    136 	     				&sc->sc_regh)) != 0) {
    137 		printf(": unable to map regs, err=%d\n", err);
    138 		return;
    139 	}
    140 
    141 	if (bus_dmamap_create(wsc->sc_dmat, MAX_DMA_SZ,
    142 			      DMA_SEGS, MAX_SEG_SZ, MAX_SEG_SZ,
    143 			      BUS_DMA_WAITOK,
    144 			      &wsc->sc_dmamap) != 0) {
    145 		printf(": failed to create dmamap\n");
    146 		return;
    147 	}
    148 
    149 	sc->sc_dmasetup = wdsc_dmasetup;
    150 	sc->sc_dmago    = wdsc_dmago;
    151 	sc->sc_dmastop  = wdsc_dmastop;
    152 
    153 	sc->sc_adapter.adapt_request = sbic_scsi_request;
    154 	sc->sc_adapter.adapt_minphys = minphys;
    155 
    156 	sc->sc_id = 7;			/* Host ID = 7 */
    157 	sc->sc_clkfreq = 200;		/* 20MHz Clock */
    158 
    159 	evcnt_attach_dynamic(&wsc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
    160 			     sc->sc_dev.dv_xname, "intr");
    161 
    162 	/* XXX: 1 = IRQ_LOCAL0 + 1 */
    163 	if ((cpu_intr_establish(1, IPL_BIO, wdsc_scsiintr, sc)) == NULL) {
    164 		printf(": unable to establish interrupt!\n");
    165 		return;
    166 	}
    167 
    168 	hpcdma_init(haa, &wsc->sc_hpcdma, DMA_SEGS);
    169 	sbic_attach(sc);
    170 	return;
    171 }
    172 
    173 /*
    174  * Prime the hardware for a DMA transfer
    175  *
    176  * Requires splbio() interrupts to be disabled by the caller
    177  */
    178 int
    179 wdsc_dmasetup(dev, addr, len, datain, dmasize)
    180 	struct sbic_softc *dev;
    181 	caddr_t *addr;
    182 	size_t *len;
    183 	int datain;
    184 	size_t *dmasize;
    185 {
    186 	struct wdsc_softc *wsc = (void *)dev;
    187 	struct hpc_dma_softc *dsc = &wsc->sc_hpcdma;
    188 	int     count, err;
    189 	void   *vaddr;
    190 
    191 	KASSERT((wsc->sc_flags & WDSC_DMA_ACTIVE) == 0);
    192 
    193 	vaddr = *addr;
    194 	count = dsc->sc_dlen = *len;
    195 	if (count) {
    196 		KASSERT((wsc->sc_flags & WDSC_DMA_MAPLOADED) == 0);
    197 
    198 		/* Build list of physical addresses for this transfer */
    199 		if ((err=bus_dmamap_load(wsc->sc_dmat, wsc->sc_dmamap,
    200 				vaddr, count,
    201 				NULL /* kernel address */,
    202 				BUS_DMA_NOWAIT)) != 0)
    203 			panic("%s: bus_dmamap_load err=%d",
    204 			      dev->sc_dev.dv_xname, err);
    205 
    206 		hpcdma_sglist_create(dsc, wsc->sc_dmamap);
    207 		wsc->sc_flags |= WDSC_DMA_MAPLOADED;
    208 
    209 		if (datain) {
    210 			dsc->sc_dmacmd = HPC_DMACTL_ACTIVE;
    211 			dsc->sc_flags |= HPCDMA_READ;
    212 		} else {
    213 			dsc->sc_dmacmd = HPC_DMACTL_ACTIVE | HPC_DMACTL_DIR;
    214 			dsc->sc_flags &= ~HPCDMA_READ;
    215 		}
    216 	}
    217 	return(count);
    218 }
    219 
    220 /*
    221  * Prime the hardware for the next DMA transfer
    222  */
    223 int
    224 wdsc_dmago(dev)
    225 	struct sbic_softc *dev;
    226 {
    227 	struct wdsc_softc *wsc = (void *)dev;
    228 	struct hpc_dma_softc *dsc = &wsc->sc_hpcdma;
    229 
    230 	if (dsc->sc_dlen == 0)
    231 		return(0);
    232 
    233 	KASSERT((wsc->sc_flags & WDSC_DMA_ACTIVE) == 0);
    234 	KASSERT((wsc->sc_flags & WDSC_DMA_MAPLOADED));
    235 
    236 	wsc->sc_flags |= WDSC_DMA_ACTIVE;
    237 
    238 	bus_dmamap_sync(wsc->sc_dmat, wsc->sc_dmamap, 0,
    239 	    		wsc->sc_dmamap->dm_mapsize,
    240 			BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
    241 
    242 	hpcdma_cntl(dsc, dsc->sc_dmacmd);	/* Thunderbirds are go! */
    243 
    244 	return(wsc->sc_dmamap->dm_mapsize);
    245 }
    246 
    247 /*
    248  * Stop DMA and unload active DMA maps
    249  */
    250 void
    251 wdsc_dmastop(dev)
    252 	struct sbic_softc *dev;
    253 {
    254 	struct wdsc_softc *wsc = (void *)dev;
    255 	struct hpc_dma_softc *dsc = &wsc->sc_hpcdma;
    256 
    257 	if (wsc->sc_flags & WDSC_DMA_ACTIVE) {
    258 		if (dsc->sc_flags & HPCDMA_READ)
    259 			hpcdma_flush(dsc);
    260 		hpcdma_cntl(dsc, 0);	/* Stop DMA */
    261 		bus_dmamap_sync(wsc->sc_dmat, wsc->sc_dmamap, 0,
    262 		    wsc->sc_dmamap->dm_mapsize,
    263 		    BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
    264 	}
    265 	if (wsc->sc_flags & WDSC_DMA_MAPLOADED)
    266 		bus_dmamap_unload(wsc->sc_dmat, wsc->sc_dmamap);
    267 	wsc->sc_flags &= ~(WDSC_DMA_ACTIVE | WDSC_DMA_MAPLOADED);
    268 }
    269 
    270 /*
    271  * WD33c93 SCSI controller interrupt
    272  */
    273 int
    274 wdsc_scsiintr(arg)
    275 	void *arg;
    276 {
    277 	struct sbic_softc *dev = arg;
    278 	struct wdsc_softc *wsc = arg;
    279 	int found;
    280 
    281 	found = sbic_intr(dev);
    282 	if (found)
    283 		wsc->sc_intrcnt.ev_count++;
    284 	return(found);
    285 }
    286