1 /* $NetBSD: wdsc.c,v 1.35 2018/09/02 16:18:50 tsutsui 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.35 2018/09/02 16:18:50 tsutsui 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 <sys/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 int wdsc_match(device_t, cfdata_t, void *);
81 void wdsc_attach(device_t, device_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 *, int, size_t *);
87 int wdsc_dmago(struct wd33c93_softc *);
88 void wdsc_dmastop(struct wd33c93_softc *);
89 void wdsc_reset(struct wd33c93_softc *);
90 int wdsc_dmaintr(void *);
91 int wdsc_scsiintr(void *);
92
93 /*
94 * Match for SCSI devices on the onboard and GIO32 adapter WD33C93 chips
95 */
96 int
wdsc_match(device_t parent,cfdata_t cf,void * aux)97 wdsc_match(device_t parent, cfdata_t cf, void *aux)
98 {
99 struct hpc_attach_args *haa = aux;
100
101 if (strcmp(haa->ha_name, cf->cf_name) == 0) {
102 vaddr_t reset, asr, reg;
103
104 reset = MIPS_PHYS_TO_KSEG1(haa->ha_sh + haa->ha_dmaoff +
105 haa->hpc_regs->scsi0_ctl);
106 asr = MIPS_PHYS_TO_KSEG1(haa->ha_sh + haa->ha_devoff);
107
108 /* XXX: hpc1 offset due to SGIMIPS_BUS_SPACE_HPC brain damage */
109 asr = (asr + 3) & ~0x3;
110
111 if (platform.badaddr((void *)reset, sizeof(reset)))
112 return 0;
113
114 *(volatile uint32_t *)reset = haa->hpc_regs->scsi_dmactl_reset;
115 delay(1000);
116 *(volatile uint32_t *)reset = 0x0;
117
118 if (platform.badaddr((void *)asr, sizeof(asr)))
119 return 0;
120
121 reg = *(volatile uint32_t *)asr;
122 if (haa->hpc_regs->revision == 3) {
123 if ((reg & 0xff) == SBIC_ASR_INT)
124 return 1;
125 } else {
126 if (((reg >> 8) & 0xff) == SBIC_ASR_INT)
127 return 1;
128 }
129 }
130
131 return 0;
132 }
133
134 /*
135 * Attach the wdsc driver
136 */
137 void
wdsc_attach(device_t parent,device_t self,void * aux)138 wdsc_attach(device_t parent, device_t self, void *aux)
139 {
140 struct wdsc_softc *wsc = device_private(self);
141 struct wd33c93_softc *sc = &wsc->sc_wd33c93;
142 struct hpc_attach_args *haa = aux;
143 int err;
144
145 sc->sc_dev = self;
146 sc->sc_regt = haa->ha_st;
147 wsc->sc_dmat = haa->ha_dmat;
148
149 wsc->sc_hpcdma.hpc = haa->hpc_regs;
150
151 if ((err = bus_space_subregion(haa->ha_st, haa->ha_sh,
152 haa->ha_devoff + 0 + 3, 1, &sc->sc_asr_regh)) != 0) {
153 printf(": unable to map asr reg, err=%d\n", err);
154 return;
155 }
156
157 if ((err = bus_space_subregion(haa->ha_st, haa->ha_sh,
158 haa->ha_devoff + 4 + 3, 1, &sc->sc_data_regh)) != 0) {
159 printf(": unable to map data reg, err=%d\n", err);
160 return;
161 }
162
163 if (bus_dmamap_create(wsc->sc_dmat, MAXPHYS,
164 wsc->sc_hpcdma.hpc->scsi_dma_segs,
165 wsc->sc_hpcdma.hpc->scsi_dma_segs_size,
166 wsc->sc_hpcdma.hpc->scsi_dma_segs_size,
167 BUS_DMA_WAITOK, &wsc->sc_dmamap) != 0) {
168 printf(": failed to create dmamap\n");
169 return;
170 }
171
172 sc->sc_dmasetup = wdsc_dmasetup;
173 sc->sc_dmago = wdsc_dmago;
174 sc->sc_dmastop = wdsc_dmastop;
175 sc->sc_reset = wdsc_reset;
176
177 sc->sc_adapter.adapt_request = wd33c93_scsi_request;
178 sc->sc_adapter.adapt_minphys = minphys;
179
180 sc->sc_id = 0; /* Host ID = 0 */
181 sc->sc_clkfreq = 200; /* 20MHz */
182 sc->sc_dmamode = SBIC_CTL_BURST_DMA;
183
184 evcnt_attach_dynamic(&wsc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
185 device_xname(sc->sc_dev), "intr");
186
187 if ((cpu_intr_establish(haa->ha_irq, IPL_BIO,
188 wdsc_scsiintr, wsc)) == NULL) {
189 printf(": unable to establish interrupt!\n");
190 return;
191 }
192
193 hpcdma_init(haa, &wsc->sc_hpcdma, wsc->sc_hpcdma.hpc->scsi_dma_segs);
194 wd33c93_attach(sc);
195 }
196
197 /*
198 * Prime the hardware for a DMA transfer
199 *
200 * Requires splbio() interrupts to be disabled by the caller
201 */
202 int
wdsc_dmasetup(struct wd33c93_softc * sc,void ** addr,size_t * len,int datain,size_t * dmasize)203 wdsc_dmasetup(struct wd33c93_softc *sc, void **addr, size_t *len, int datain,
204 size_t *dmasize)
205 {
206 struct wdsc_softc *wsc = (struct wdsc_softc *)sc;
207 struct hpc_dma_softc *dsc = &wsc->sc_hpcdma;
208 int count, err;
209 void *vaddr;
210
211 KASSERT((wsc->sc_flags & WDSC_DMA_ACTIVE) == 0);
212
213 vaddr = *addr;
214 count = dsc->sc_dlen = *len;
215 if (count) {
216 KASSERT((wsc->sc_flags & WDSC_DMA_MAPLOADED) == 0);
217
218 /* Build list of physical addresses for this transfer */
219 if ((err = bus_dmamap_load(wsc->sc_dmat, wsc->sc_dmamap,
220 vaddr, count, NULL /* kernel address */,
221 BUS_DMA_NOWAIT)) != 0)
222 panic("%s: bus_dmamap_load err=%d",
223 device_xname(sc->sc_dev), err);
224
225 hpcdma_sglist_create(dsc, wsc->sc_dmamap);
226 wsc->sc_flags |= WDSC_DMA_MAPLOADED;
227
228 if (datain) {
229 dsc->sc_dmacmd =
230 wsc->sc_hpcdma.hpc->scsi_dma_datain_cmd;
231 dsc->sc_flags |= HPCDMA_READ;
232 } else {
233 dsc->sc_dmacmd =
234 wsc->sc_hpcdma.hpc->scsi_dma_dataout_cmd;
235 dsc->sc_flags &= ~HPCDMA_READ;
236 }
237 }
238 return count;
239 }
240
241 /*
242 * Prime the hardware for the next DMA transfer
243 */
244 int
wdsc_dmago(struct wd33c93_softc * sc)245 wdsc_dmago(struct wd33c93_softc *sc)
246 {
247 struct wdsc_softc *wsc = (struct wdsc_softc *)sc;
248 struct hpc_dma_softc *dsc = &wsc->sc_hpcdma;
249
250 if (dsc->sc_dlen == 0)
251 return 0;
252
253 KASSERT((wsc->sc_flags & WDSC_DMA_ACTIVE) == 0);
254 KASSERT((wsc->sc_flags & WDSC_DMA_MAPLOADED));
255
256 wsc->sc_flags |= WDSC_DMA_ACTIVE;
257
258 bus_dmamap_sync(wsc->sc_dmat, wsc->sc_dmamap,
259 0, wsc->sc_dmamap->dm_mapsize,
260 (dsc->sc_flags & HPCDMA_READ) ?
261 BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
262
263 hpcdma_cntl(dsc, dsc->sc_dmacmd); /* Thunderbirds are go! */
264
265 return wsc->sc_dmamap->dm_mapsize;
266 }
267
268 /*
269 * Stop DMA and unload active DMA maps
270 */
271 void
wdsc_dmastop(struct wd33c93_softc * sc)272 wdsc_dmastop(struct wd33c93_softc *sc)
273 {
274 struct wdsc_softc *wsc = (struct wdsc_softc *)sc;
275 struct hpc_dma_softc *dsc = &wsc->sc_hpcdma;
276
277 if (wsc->sc_flags & WDSC_DMA_ACTIVE) {
278 if (dsc->sc_flags & HPCDMA_READ)
279 hpcdma_flush(dsc);
280 hpcdma_cntl(dsc, 0); /* Stop DMA */
281 bus_dmamap_sync(wsc->sc_dmat, wsc->sc_dmamap,
282 0, wsc->sc_dmamap->dm_mapsize,
283 (dsc->sc_flags & HPCDMA_READ) ?
284 BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
285 }
286 if (wsc->sc_flags & WDSC_DMA_MAPLOADED)
287 bus_dmamap_unload(wsc->sc_dmat, wsc->sc_dmamap);
288 wsc->sc_flags &= ~(WDSC_DMA_ACTIVE | WDSC_DMA_MAPLOADED);
289 }
290
291 /*
292 * Reset the controller.
293 */
294 void
wdsc_reset(struct wd33c93_softc * sc)295 wdsc_reset(struct wd33c93_softc *sc)
296 {
297 struct wdsc_softc *wsc = (struct wdsc_softc *)sc;
298 struct hpc_dma_softc *dsc = &wsc->sc_hpcdma;
299
300 hpcdma_reset(dsc);
301 }
302
303 /*
304 * WD33c93 SCSI controller interrupt
305 */
306 int
wdsc_scsiintr(void * arg)307 wdsc_scsiintr(void *arg)
308 {
309 struct wdsc_softc *wsc = arg;
310 struct wd33c93_softc *sc = &wsc->sc_wd33c93;
311 int found;
312
313 found = wd33c93_intr(sc);
314 if (found)
315 wsc->sc_intrcnt.ev_count++;
316 return found;
317 }
318