siop.c revision 1.21.2.5 1 1.21.2.5 he /* $NetBSD: siop.c,v 1.21.2.5 2000/12/15 04:48:03 he Exp $ */
2 1.1 bouyer
3 1.1 bouyer /*
4 1.1 bouyer * Copyright (c) 2000 Manuel Bouyer.
5 1.1 bouyer *
6 1.1 bouyer * Redistribution and use in source and binary forms, with or without
7 1.1 bouyer * modification, are permitted provided that the following conditions
8 1.1 bouyer * are met:
9 1.1 bouyer * 1. Redistributions of source code must retain the above copyright
10 1.1 bouyer * notice, this list of conditions and the following disclaimer.
11 1.1 bouyer * 2. Redistributions in binary form must reproduce the above copyright
12 1.1 bouyer * notice, this list of conditions and the following disclaimer in the
13 1.1 bouyer * documentation and/or other materials provided with the distribution.
14 1.1 bouyer * 3. All advertising materials mentioning features or use of this software
15 1.1 bouyer * must display the following acknowledgement:
16 1.5 bouyer * This product includes software developed by Manuel Bouyer
17 1.5 bouyer * 4. The name of the author may not be used to endorse or promote products
18 1.5 bouyer * derived from this software without specific prior written permission.
19 1.1 bouyer *
20 1.14 bouyer * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21 1.14 bouyer * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 1.14 bouyer * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 1.14 bouyer * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24 1.14 bouyer * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 1.14 bouyer * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 1.14 bouyer * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 1.14 bouyer * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 1.14 bouyer * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29 1.14 bouyer * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 1.1 bouyer *
31 1.1 bouyer */
32 1.1 bouyer
33 1.1 bouyer /* SYM53c7/8xx PCI-SCSI I/O Processors driver */
34 1.1 bouyer
35 1.1 bouyer #include <sys/param.h>
36 1.1 bouyer #include <sys/systm.h>
37 1.1 bouyer #include <sys/device.h>
38 1.1 bouyer #include <sys/malloc.h>
39 1.1 bouyer #include <sys/buf.h>
40 1.1 bouyer #include <sys/kernel.h>
41 1.1 bouyer
42 1.1 bouyer #include <machine/endian.h>
43 1.1 bouyer #include <machine/bus.h>
44 1.1 bouyer
45 1.1 bouyer #include <dev/microcode/siop/siop.out>
46 1.1 bouyer
47 1.1 bouyer #include <dev/scsipi/scsi_all.h>
48 1.1 bouyer #include <dev/scsipi/scsi_message.h>
49 1.1 bouyer #include <dev/scsipi/scsipi_all.h>
50 1.1 bouyer
51 1.1 bouyer #include <dev/scsipi/scsiconf.h>
52 1.1 bouyer
53 1.1 bouyer #include <dev/ic/siopreg.h>
54 1.1 bouyer #include <dev/ic/siopvar.h>
55 1.14 bouyer #include <dev/ic/siopvar_common.h>
56 1.1 bouyer
57 1.21.2.5 he #ifndef DEBUG
58 1.15 bouyer #undef DEBUG
59 1.21.2.5 he #endif
60 1.21.2.5 he #undef SIOP_DEBUG
61 1.21.2.5 he #undef SIOP_DEBUG_DR
62 1.21.2.5 he #undef SIOP_DEBUG_INTR
63 1.21.2.5 he #undef SIOP_DEBUG_SCHED
64 1.2 bouyer #undef DUMP_SCRIPT
65 1.2 bouyer
66 1.2 bouyer #define SIOP_STATS
67 1.2 bouyer
68 1.1 bouyer #ifndef SIOP_DEFAULT_TARGET
69 1.1 bouyer #define SIOP_DEFAULT_TARGET 7
70 1.1 bouyer #endif
71 1.1 bouyer
72 1.16 bouyer /* number of cmd descriptors per block */
73 1.16 bouyer #define SIOP_NCMDPB (NBPG / sizeof(struct siop_xfer))
74 1.1 bouyer
75 1.21.2.5 he /* Number of scheduler slot (needs to match script) */
76 1.21.2.5 he #define SIOP_NSLOTS 40
77 1.21.2.5 he
78 1.1 bouyer void siop_reset __P((struct siop_softc *));
79 1.2 bouyer void siop_handle_reset __P((struct siop_softc *));
80 1.21.2.5 he int siop_handle_qtag_reject __P((struct siop_cmd *));
81 1.2 bouyer void siop_scsicmd_end __P((struct siop_cmd *));
82 1.1 bouyer void siop_start __P((struct siop_softc *));
83 1.1 bouyer void siop_timeout __P((void *));
84 1.1 bouyer int siop_scsicmd __P((struct scsipi_xfer *));
85 1.2 bouyer void siop_dump_script __P((struct siop_softc *));
86 1.16 bouyer int siop_morecbd __P((struct siop_softc *));
87 1.21.2.5 he struct siop_lunsw *siop_get_lunsw __P((struct siop_softc *));
88 1.21.2.5 he void siop_add_reselsw __P((struct siop_softc *, int));
89 1.21.2.5 he void siop_update_scntl3 __P((struct siop_softc *, struct siop_target *));
90 1.1 bouyer
91 1.1 bouyer struct scsipi_adapter siop_adapter = {
92 1.1 bouyer 0,
93 1.1 bouyer siop_scsicmd,
94 1.1 bouyer siop_minphys,
95 1.2 bouyer siop_ioctl,
96 1.19 tsutsui NULL,
97 1.1 bouyer NULL,
98 1.1 bouyer };
99 1.1 bouyer
100 1.1 bouyer struct scsipi_device siop_dev = {
101 1.1 bouyer NULL,
102 1.1 bouyer NULL,
103 1.1 bouyer NULL,
104 1.1 bouyer NULL,
105 1.1 bouyer };
106 1.1 bouyer
107 1.2 bouyer #ifdef SIOP_STATS
108 1.2 bouyer static int siop_stat_intr = 0;
109 1.2 bouyer static int siop_stat_intr_shortxfer = 0;
110 1.2 bouyer static int siop_stat_intr_sdp = 0;
111 1.2 bouyer static int siop_stat_intr_done = 0;
112 1.2 bouyer static int siop_stat_intr_xferdisc = 0;
113 1.21.2.5 he static int siop_stat_intr_lunresel = 0;
114 1.21.2.5 he static int siop_stat_intr_qfull = 0;
115 1.2 bouyer void siop_printstats __P((void));
116 1.2 bouyer #define INCSTAT(x) x++
117 1.2 bouyer #else
118 1.2 bouyer #define INCSTAT(x)
119 1.2 bouyer #endif
120 1.2 bouyer
121 1.21.2.5 he static __inline__ void siop_script_sync __P((struct siop_softc *, int));
122 1.2 bouyer static __inline__ void
123 1.21.2.5 he siop_script_sync(sc, ops)
124 1.21.2.5 he struct siop_softc *sc;
125 1.2 bouyer int ops;
126 1.2 bouyer {
127 1.21.2.5 he if ((sc->features & SF_CHIP_RAM) == 0)
128 1.21.2.5 he bus_dmamap_sync(sc->sc_dmat, sc->sc_scriptdma, 0, NBPG, ops);
129 1.2 bouyer }
130 1.2 bouyer
131 1.21.2.5 he static __inline__ u_int32_t siop_script_read __P((struct siop_softc *, u_int));
132 1.21.2.5 he static __inline__ u_int32_t
133 1.21.2.5 he siop_script_read(sc, offset)
134 1.21.2.5 he struct siop_softc *sc;
135 1.21.2.5 he u_int offset;
136 1.21.2.5 he {
137 1.21.2.5 he if (sc->features & SF_CHIP_RAM) {
138 1.21.2.5 he return bus_space_read_4(sc->sc_ramt, sc->sc_ramh, offset * 4);
139 1.21.2.5 he } else {
140 1.21.2.5 he return le32toh(sc->sc_script[offset]);
141 1.21.2.5 he }
142 1.21.2.5 he }
143 1.21.2.5 he
144 1.21.2.5 he static __inline__ void siop_script_write __P((struct siop_softc *, u_int,
145 1.21.2.5 he u_int32_t));
146 1.2 bouyer static __inline__ void
147 1.21.2.5 he siop_script_write(sc, offset, val)
148 1.2 bouyer struct siop_softc *sc;
149 1.21.2.5 he u_int offset;
150 1.21.2.5 he u_int32_t val;
151 1.2 bouyer {
152 1.21.2.5 he if (sc->features & SF_CHIP_RAM) {
153 1.21.2.5 he bus_space_write_4(sc->sc_ramt, sc->sc_ramh, offset * 4, val);
154 1.21.2.5 he } else {
155 1.21.2.5 he sc->sc_script[offset] = htole32(val);
156 1.21.2.5 he }
157 1.2 bouyer }
158 1.2 bouyer
159 1.1 bouyer void
160 1.1 bouyer siop_attach(sc)
161 1.1 bouyer struct siop_softc *sc;
162 1.1 bouyer {
163 1.1 bouyer int error, i;
164 1.1 bouyer bus_dma_segment_t seg;
165 1.1 bouyer int rseg;
166 1.1 bouyer
167 1.1 bouyer /*
168 1.21.2.5 he * Allocate DMA-safe memory for the script and map it.
169 1.1 bouyer */
170 1.17 bouyer if ((sc->features & SF_CHIP_RAM) == 0) {
171 1.17 bouyer error = bus_dmamem_alloc(sc->sc_dmat, NBPG,
172 1.17 bouyer NBPG, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT);
173 1.17 bouyer if (error) {
174 1.17 bouyer printf("%s: unable to allocate script DMA memory, "
175 1.17 bouyer "error = %d\n", sc->sc_dev.dv_xname, error);
176 1.17 bouyer return;
177 1.17 bouyer }
178 1.17 bouyer error = bus_dmamem_map(sc->sc_dmat, &seg, rseg, NBPG,
179 1.17 bouyer (caddr_t *)&sc->sc_script, BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
180 1.17 bouyer if (error) {
181 1.17 bouyer printf("%s: unable to map script DMA memory, "
182 1.17 bouyer "error = %d\n", sc->sc_dev.dv_xname, error);
183 1.17 bouyer return;
184 1.17 bouyer }
185 1.17 bouyer error = bus_dmamap_create(sc->sc_dmat, NBPG, 1,
186 1.17 bouyer NBPG, 0, BUS_DMA_NOWAIT, &sc->sc_scriptdma);
187 1.17 bouyer if (error) {
188 1.17 bouyer printf("%s: unable to create script DMA map, "
189 1.17 bouyer "error = %d\n", sc->sc_dev.dv_xname, error);
190 1.17 bouyer return;
191 1.17 bouyer }
192 1.17 bouyer error = bus_dmamap_load(sc->sc_dmat, sc->sc_scriptdma,
193 1.21.2.5 he sc->sc_script, NBPG, NULL, BUS_DMA_NOWAIT);
194 1.17 bouyer if (error) {
195 1.17 bouyer printf("%s: unable to load script DMA map, "
196 1.17 bouyer "error = %d\n", sc->sc_dev.dv_xname, error);
197 1.17 bouyer return;
198 1.17 bouyer }
199 1.17 bouyer sc->sc_scriptaddr = sc->sc_scriptdma->dm_segs[0].ds_addr;
200 1.21.2.5 he sc->ram_size = NBPG;
201 1.1 bouyer }
202 1.1 bouyer TAILQ_INIT(&sc->free_list);
203 1.21.2.5 he TAILQ_INIT(&sc->ready_list);
204 1.21.2.5 he TAILQ_INIT(&sc->urgent_list);
205 1.16 bouyer TAILQ_INIT(&sc->cmds);
206 1.21.2.5 he TAILQ_INIT(&sc->lunsw_list);
207 1.21.2.5 he sc->sc_currschedslot = 0;
208 1.21.2.5 he #ifdef SIOP_DEBUG
209 1.21.2.5 he printf("%s: script size = %d, PHY addr=0x%x, VIRT=%p\n",
210 1.2 bouyer sc->sc_dev.dv_xname, (int)sizeof(siop_script),
211 1.21.2.5 he (u_int32_t)sc->sc_scriptaddr, sc->sc_script);
212 1.1 bouyer #endif
213 1.1 bouyer
214 1.1 bouyer sc->sc_link.adapter_softc = sc;
215 1.21.2.5 he sc->sc_link.openings = 2;
216 1.1 bouyer sc->sc_link.scsipi_scsi.channel = SCSI_CHANNEL_ONLY_ONE;
217 1.1 bouyer sc->sc_link.scsipi_scsi.max_target =
218 1.1 bouyer (sc->features & SF_BUS_WIDE) ? 15 : 7;
219 1.1 bouyer sc->sc_link.scsipi_scsi.max_lun = 7;
220 1.1 bouyer sc->sc_link.scsipi_scsi.adapter_target = bus_space_read_1(sc->sc_rt,
221 1.1 bouyer sc->sc_rh, SIOP_SCID);
222 1.2 bouyer if (sc->sc_link.scsipi_scsi.adapter_target == 0 ||
223 1.2 bouyer sc->sc_link.scsipi_scsi.adapter_target >
224 1.1 bouyer sc->sc_link.scsipi_scsi.max_target)
225 1.1 bouyer sc->sc_link.scsipi_scsi.adapter_target = SIOP_DEFAULT_TARGET;
226 1.1 bouyer sc->sc_link.type = BUS_SCSI;
227 1.1 bouyer sc->sc_link.adapter = &siop_adapter;
228 1.1 bouyer sc->sc_link.device = &siop_dev;
229 1.1 bouyer sc->sc_link.flags = 0;
230 1.1 bouyer
231 1.7 bouyer for (i = 0; i < 16; i++)
232 1.7 bouyer sc->targets[i] = NULL;
233 1.7 bouyer
234 1.7 bouyer /* find min/max sync period for this chip */
235 1.7 bouyer sc->maxsync = 0;
236 1.7 bouyer sc->minsync = 255;
237 1.7 bouyer for (i = 0; i < sizeof(scf_period) / sizeof(scf_period[0]); i++) {
238 1.7 bouyer if (sc->clock_period != scf_period[i].clock)
239 1.7 bouyer continue;
240 1.7 bouyer if (sc->maxsync < scf_period[i].period)
241 1.7 bouyer sc->maxsync = scf_period[i].period;
242 1.7 bouyer if (sc->minsync > scf_period[i].period)
243 1.7 bouyer sc->minsync = scf_period[i].period;
244 1.7 bouyer }
245 1.7 bouyer if (sc->maxsync == 255 || sc->minsync == 0)
246 1.7 bouyer panic("siop: can't find my sync parameters\n");
247 1.21.2.2 bouyer /* Do a bus reset, so that devices fall back to narrow/async */
248 1.21.2.2 bouyer siop_resetbus(sc);
249 1.21.2.2 bouyer /*
250 1.21.2.2 bouyer * siop_reset() will reset the chip, thus clearing pending interrupts
251 1.21.2.2 bouyer */
252 1.1 bouyer siop_reset(sc);
253 1.2 bouyer #ifdef DUMP_SCRIPT
254 1.2 bouyer siop_dump_script(sc);
255 1.2 bouyer #endif
256 1.1 bouyer
257 1.1 bouyer config_found((struct device*)sc, &sc->sc_link, scsiprint);
258 1.1 bouyer }
259 1.1 bouyer
260 1.1 bouyer void
261 1.1 bouyer siop_reset(sc)
262 1.1 bouyer struct siop_softc *sc;
263 1.1 bouyer {
264 1.4 bouyer int i, j;
265 1.21.2.5 he struct siop_lunsw *lunsw;
266 1.4 bouyer
267 1.14 bouyer siop_common_reset(sc);
268 1.1 bouyer
269 1.1 bouyer /* copy and patch the script */
270 1.17 bouyer if (sc->features & SF_CHIP_RAM) {
271 1.17 bouyer bus_space_write_region_4(sc->sc_ramt, sc->sc_ramh, 0,
272 1.17 bouyer siop_script, sizeof(siop_script) / sizeof(siop_script[0]));
273 1.17 bouyer for (j = 0; j <
274 1.21.2.5 he (sizeof(E_abs_msgin_Used) / sizeof(E_abs_msgin_Used[0]));
275 1.17 bouyer j++) {
276 1.17 bouyer bus_space_write_4(sc->sc_ramt, sc->sc_ramh,
277 1.21.2.5 he E_abs_msgin_Used[j] * 4,
278 1.21.2.5 he sc->sc_scriptaddr + Ent_msgin_space);
279 1.17 bouyer }
280 1.17 bouyer } else {
281 1.17 bouyer for (j = 0;
282 1.17 bouyer j < (sizeof(siop_script) / sizeof(siop_script[0])); j++) {
283 1.17 bouyer sc->sc_script[j] = htole32(siop_script[j]);
284 1.17 bouyer }
285 1.17 bouyer for (j = 0; j <
286 1.21.2.5 he (sizeof(E_abs_msgin_Used) / sizeof(E_abs_msgin_Used[0]));
287 1.17 bouyer j++) {
288 1.21.2.5 he sc->sc_script[E_abs_msgin_Used[j]] =
289 1.21.2.5 he htole32(sc->sc_scriptaddr + Ent_msgin_space);
290 1.17 bouyer }
291 1.4 bouyer }
292 1.21.2.5 he sc->script_free_lo = sizeof(siop_script) / sizeof(siop_script[0]);
293 1.21.2.5 he sc->script_free_hi = sc->ram_size / 4;
294 1.21.2.5 he
295 1.21.2.5 he /* free used and unused lun switches */
296 1.21.2.5 he while((lunsw = TAILQ_FIRST(&sc->lunsw_list)) != NULL) {
297 1.21.2.5 he #ifdef SIOP_DEBUG
298 1.21.2.5 he printf("%s: free lunsw at offset %d\n",
299 1.21.2.5 he sc->sc_dev.dv_xname, lunsw->lunsw_off);
300 1.21.2.5 he #endif
301 1.21.2.5 he TAILQ_REMOVE(&sc->lunsw_list, lunsw, next);
302 1.21.2.5 he free(lunsw, M_DEVBUF);
303 1.21.2.5 he }
304 1.21.2.5 he TAILQ_INIT(&sc->lunsw_list);
305 1.21.2.5 he /* restore reselect switch */
306 1.21.2.5 he for (i = 0; i <= sc->sc_link.scsipi_scsi.max_target; i++) {
307 1.21.2.5 he if (sc->targets[i] == NULL)
308 1.21.2.5 he continue;
309 1.21.2.5 he #ifdef SIOP_DEBUG
310 1.21.2.5 he printf("%s: restore sw for target %d\n",
311 1.21.2.5 he sc->sc_dev.dv_xname, i);
312 1.21.2.5 he #endif
313 1.21.2.5 he free(sc->targets[i]->lunsw, M_DEVBUF);
314 1.21.2.5 he sc->targets[i]->lunsw = siop_get_lunsw(sc);
315 1.21.2.5 he if (sc->targets[i]->lunsw == NULL) {
316 1.21.2.5 he printf("%s: can't alloc lunsw for target %d\n",
317 1.21.2.5 he sc->sc_dev.dv_xname, i);
318 1.21.2.5 he break;
319 1.4 bouyer }
320 1.21.2.5 he siop_add_reselsw(sc, i);
321 1.4 bouyer }
322 1.1 bouyer
323 1.2 bouyer /* start script */
324 1.21.2.1 bouyer if ((sc->features & SF_CHIP_RAM) == 0) {
325 1.21.2.1 bouyer bus_dmamap_sync(sc->sc_dmat, sc->sc_scriptdma, 0, NBPG,
326 1.21.2.1 bouyer BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
327 1.21.2.1 bouyer }
328 1.2 bouyer bus_space_write_4(sc->sc_rt, sc->sc_rh, SIOP_DSP,
329 1.17 bouyer sc->sc_scriptaddr + Ent_reselect);
330 1.1 bouyer }
331 1.1 bouyer
332 1.1 bouyer #if 0
333 1.1 bouyer #define CALL_SCRIPT(ent) do {\
334 1.1 bouyer printf ("start script DSA 0x%lx DSP 0x%lx\n", \
335 1.4 bouyer siop_cmd->dsa, \
336 1.17 bouyer sc->sc_scriptaddr + ent); \
337 1.17 bouyer bus_space_write_4(sc->sc_rt, sc->sc_rh, SIOP_DSP, sc->sc_scriptaddr + ent); \
338 1.1 bouyer } while (0)
339 1.1 bouyer #else
340 1.1 bouyer #define CALL_SCRIPT(ent) do {\
341 1.17 bouyer bus_space_write_4(sc->sc_rt, sc->sc_rh, SIOP_DSP, sc->sc_scriptaddr + ent); \
342 1.1 bouyer } while (0)
343 1.1 bouyer #endif
344 1.1 bouyer
345 1.1 bouyer int
346 1.1 bouyer siop_intr(v)
347 1.1 bouyer void *v;
348 1.1 bouyer {
349 1.1 bouyer struct siop_softc *sc = v;
350 1.7 bouyer struct siop_target *siop_target;
351 1.1 bouyer struct siop_cmd *siop_cmd;
352 1.21.2.5 he struct siop_lun *siop_lun;
353 1.1 bouyer struct scsipi_xfer *xs;
354 1.21.2.5 he int istat, sist, sstat1, dstat;
355 1.1 bouyer u_int32_t irqcode;
356 1.1 bouyer int need_reset = 0;
357 1.21.2.5 he int offset, target, lun, tag;
358 1.2 bouyer bus_addr_t dsa;
359 1.16 bouyer struct siop_cbd *cbdp;
360 1.21.2.5 he int freetarget = 0;
361 1.1 bouyer
362 1.1 bouyer istat = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_ISTAT);
363 1.2 bouyer if ((istat & (ISTAT_INTF | ISTAT_DIP | ISTAT_SIP)) == 0)
364 1.2 bouyer return 0;
365 1.2 bouyer INCSTAT(siop_stat_intr);
366 1.1 bouyer if (istat & ISTAT_INTF) {
367 1.1 bouyer printf("INTRF\n");
368 1.1 bouyer bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_ISTAT, ISTAT_INTF);
369 1.1 bouyer }
370 1.2 bouyer /* use DSA to find the current siop_cmd */
371 1.2 bouyer dsa = bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_DSA);
372 1.16 bouyer for (cbdp = TAILQ_FIRST(&sc->cmds); cbdp != NULL;
373 1.16 bouyer cbdp = TAILQ_NEXT(cbdp, next)) {
374 1.16 bouyer if (dsa >= cbdp->xferdma->dm_segs[0].ds_addr &&
375 1.16 bouyer dsa < cbdp->xferdma->dm_segs[0].ds_addr + NBPG) {
376 1.16 bouyer dsa -= cbdp->xferdma->dm_segs[0].ds_addr;
377 1.16 bouyer siop_cmd = &cbdp->cmds[dsa / sizeof(struct siop_xfer)];
378 1.16 bouyer siop_table_sync(siop_cmd,
379 1.16 bouyer BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
380 1.16 bouyer break;
381 1.16 bouyer }
382 1.16 bouyer }
383 1.16 bouyer if (cbdp == NULL) {
384 1.2 bouyer siop_cmd = NULL;
385 1.2 bouyer }
386 1.21.2.5 he if (siop_cmd) {
387 1.21.2.5 he xs = siop_cmd->xs;
388 1.21.2.5 he siop_target = siop_cmd->siop_target;
389 1.21.2.5 he target = siop_cmd->xs->sc_link->scsipi_scsi.target;
390 1.21.2.5 he lun = siop_cmd->xs->sc_link->scsipi_scsi.lun;
391 1.21.2.5 he tag = siop_cmd->tag;
392 1.21.2.5 he siop_lun = siop_target->siop_lun[lun];
393 1.21.2.5 he #ifdef DIAGNOSTIC
394 1.21.2.5 he if (siop_cmd->status != CMDST_ACTIVE &&
395 1.21.2.5 he siop_cmd->status != CMDST_SENSE_ACTIVE) {
396 1.21.2.5 he printf("siop_cmd (lun %d) not active (%d)\n",
397 1.21.2.5 he lun, siop_cmd->status);
398 1.21.2.5 he xs = NULL;
399 1.21.2.5 he siop_target = NULL;
400 1.21.2.5 he target = -1;
401 1.21.2.5 he lun = -1;
402 1.21.2.5 he tag = -1;
403 1.21.2.5 he siop_lun = NULL;
404 1.21.2.5 he siop_cmd = NULL;
405 1.21.2.5 he } else if (siop_lun->siop_tag[tag].active != siop_cmd) {
406 1.21.2.5 he printf("siop_cmd (lun %d tag %d) not in siop_lun "
407 1.21.2.5 he "active (%p != %p)\n", lun, tag, siop_cmd,
408 1.21.2.5 he siop_lun->siop_tag[tag].active);
409 1.21.2.5 he }
410 1.21.2.5 he #endif
411 1.21.2.5 he } else {
412 1.21.2.5 he xs = NULL;
413 1.21.2.5 he siop_target = NULL;
414 1.21.2.5 he target = -1;
415 1.21.2.5 he lun = -1;
416 1.21.2.5 he tag = -1;
417 1.21.2.5 he siop_lun = NULL;
418 1.21.2.5 he }
419 1.1 bouyer if (istat & ISTAT_DIP) {
420 1.1 bouyer dstat = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_DSTAT);
421 1.2 bouyer if (dstat & DSTAT_SSI) {
422 1.2 bouyer printf("single step dsp 0x%08x dsa 0x08%x\n",
423 1.7 bouyer (int)(bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_DSP) -
424 1.17 bouyer sc->sc_scriptaddr),
425 1.2 bouyer bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_DSA));
426 1.2 bouyer if ((dstat & ~(DSTAT_DFE | DSTAT_SSI)) == 0 &&
427 1.2 bouyer (istat & ISTAT_SIP) == 0) {
428 1.2 bouyer bus_space_write_1(sc->sc_rt, sc->sc_rh,
429 1.2 bouyer SIOP_DCNTL, bus_space_read_1(sc->sc_rt,
430 1.2 bouyer sc->sc_rh, SIOP_DCNTL) | DCNTL_STD);
431 1.2 bouyer }
432 1.2 bouyer return 1;
433 1.2 bouyer }
434 1.2 bouyer if (dstat & ~(DSTAT_SIR | DSTAT_DFE | DSTAT_SSI)) {
435 1.1 bouyer printf("DMA IRQ:");
436 1.1 bouyer if (dstat & DSTAT_IID)
437 1.1 bouyer printf(" Illegal instruction");
438 1.1 bouyer if (dstat & DSTAT_ABRT)
439 1.1 bouyer printf(" abort");
440 1.1 bouyer if (dstat & DSTAT_BF)
441 1.1 bouyer printf(" bus fault");
442 1.1 bouyer if (dstat & DSTAT_MDPE)
443 1.1 bouyer printf(" parity");
444 1.1 bouyer if (dstat & DSTAT_DFE)
445 1.1 bouyer printf(" dma fifo empty");
446 1.1 bouyer printf(", DSP=0x%x DSA=0x%x: ",
447 1.7 bouyer (int)(bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_DSP) -
448 1.17 bouyer sc->sc_scriptaddr),
449 1.1 bouyer bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_DSA));
450 1.2 bouyer if (siop_cmd)
451 1.1 bouyer printf("last msg_in=0x%x status=0x%x\n",
452 1.21.2.5 he siop_cmd->siop_tables.msg_in[0],
453 1.21.2.5 he le32toh(siop_cmd->siop_tables.status));
454 1.20 bouyer else
455 1.20 bouyer printf("%s: current DSA invalid\n",
456 1.20 bouyer sc->sc_dev.dv_xname);
457 1.1 bouyer need_reset = 1;
458 1.1 bouyer }
459 1.1 bouyer }
460 1.1 bouyer if (istat & ISTAT_SIP) {
461 1.1 bouyer if (istat & ISTAT_DIP)
462 1.8 bouyer delay(10);
463 1.21.2.5 he /*
464 1.21.2.5 he * Can't read sist0 & sist1 independantly, or we have to
465 1.21.2.5 he * insert delay
466 1.21.2.5 he */
467 1.21.2.5 he sist = bus_space_read_2(sc->sc_rt, sc->sc_rh, SIOP_SIST0);
468 1.1 bouyer sstat1 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SSTAT1);
469 1.21.2.5 he #ifdef SIOP_DEBUG_INTR
470 1.21.2.5 he printf("scsi interrupt, sist=0x%x sstat1=0x%x "
471 1.21.2.5 he "DSA=0x%x DSP=0x%lx\n", sist,
472 1.1 bouyer bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SSTAT1),
473 1.1 bouyer bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_DSA),
474 1.8 bouyer (u_long)(bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_DSP) -
475 1.17 bouyer sc->sc_scriptaddr));
476 1.1 bouyer #endif
477 1.21.2.5 he if (sist & SIST0_RST) {
478 1.2 bouyer siop_handle_reset(sc);
479 1.1 bouyer siop_start(sc);
480 1.2 bouyer /* no table to flush here */
481 1.1 bouyer return 1;
482 1.1 bouyer }
483 1.21.2.5 he if (sist & SIST0_SGE) {
484 1.1 bouyer if (siop_cmd)
485 1.1 bouyer scsi_print_addr(xs->sc_link);
486 1.1 bouyer else
487 1.1 bouyer printf("%s:", sc->sc_dev.dv_xname);
488 1.1 bouyer printf("scsi gross error\n");
489 1.1 bouyer goto reset;
490 1.1 bouyer }
491 1.21.2.5 he if ((sist & SIST0_MA) && need_reset == 0) {
492 1.1 bouyer if (siop_cmd) {
493 1.8 bouyer int scratcha0;
494 1.8 bouyer dstat = bus_space_read_1(sc->sc_rt, sc->sc_rh,
495 1.8 bouyer SIOP_DSTAT);
496 1.3 bouyer /*
497 1.3 bouyer * first restore DSA, in case we were in a S/G
498 1.3 bouyer * operation.
499 1.3 bouyer */
500 1.3 bouyer bus_space_write_4(sc->sc_rt, sc->sc_rh,
501 1.4 bouyer SIOP_DSA, siop_cmd->dsa);
502 1.8 bouyer scratcha0 = bus_space_read_1(sc->sc_rt,
503 1.8 bouyer sc->sc_rh, SIOP_SCRATCHA);
504 1.1 bouyer switch (sstat1 & SSTAT1_PHASE_MASK) {
505 1.1 bouyer case SSTAT1_PHASE_STATUS:
506 1.1 bouyer /*
507 1.1 bouyer * previous phase may be aborted for any reason
508 1.1 bouyer * ( for example, the target has less data to
509 1.1 bouyer * transfer than requested). Just go to status
510 1.1 bouyer * and the command should terminate.
511 1.1 bouyer */
512 1.2 bouyer INCSTAT(siop_stat_intr_shortxfer);
513 1.8 bouyer if ((dstat & DSTAT_DFE) == 0)
514 1.8 bouyer siop_clearfifo(sc);
515 1.2 bouyer /* no table to flush here */
516 1.21.2.5 he CALL_SCRIPT(Ent_status);
517 1.1 bouyer return 1;
518 1.1 bouyer case SSTAT1_PHASE_MSGIN:
519 1.1 bouyer /*
520 1.1 bouyer * target may be ready to disconnect
521 1.1 bouyer * Save data pointers just in case.
522 1.1 bouyer */
523 1.2 bouyer INCSTAT(siop_stat_intr_xferdisc);
524 1.8 bouyer if (scratcha0 & A_flag_data)
525 1.8 bouyer siop_sdp(siop_cmd);
526 1.8 bouyer else if ((dstat & DSTAT_DFE) == 0)
527 1.8 bouyer siop_clearfifo(sc);
528 1.8 bouyer bus_space_write_1(sc->sc_rt, sc->sc_rh,
529 1.8 bouyer SIOP_SCRATCHA,
530 1.8 bouyer scratcha0 & ~A_flag_data);
531 1.2 bouyer siop_table_sync(siop_cmd,
532 1.2 bouyer BUS_DMASYNC_PREREAD |
533 1.2 bouyer BUS_DMASYNC_PREWRITE);
534 1.1 bouyer CALL_SCRIPT(Ent_msgin);
535 1.1 bouyer return 1;
536 1.1 bouyer }
537 1.1 bouyer printf("%s: unexpected phase mismatch %d\n",
538 1.1 bouyer sc->sc_dev.dv_xname,
539 1.1 bouyer sstat1 & SSTAT1_PHASE_MASK);
540 1.1 bouyer } else {
541 1.1 bouyer printf("%s: phase mismatch without command\n",
542 1.1 bouyer sc->sc_dev.dv_xname);
543 1.1 bouyer }
544 1.1 bouyer need_reset = 1;
545 1.1 bouyer }
546 1.21.2.5 he if (sist & SIST0_PAR) {
547 1.1 bouyer /* parity error, reset */
548 1.1 bouyer if (siop_cmd)
549 1.1 bouyer scsi_print_addr(xs->sc_link);
550 1.1 bouyer else
551 1.1 bouyer printf("%s:", sc->sc_dev.dv_xname);
552 1.1 bouyer printf("parity error\n");
553 1.11 bouyer goto reset;
554 1.1 bouyer }
555 1.21.2.5 he if ((sist & (SIST1_STO << 8)) && need_reset == 0) {
556 1.1 bouyer /* selection time out, assume there's no device here */
557 1.1 bouyer if (siop_cmd) {
558 1.1 bouyer siop_cmd->status = CMDST_DONE;
559 1.1 bouyer xs->error = XS_SELTIMEOUT;
560 1.21.2.5 he freetarget = 1;
561 1.1 bouyer goto end;
562 1.1 bouyer } else {
563 1.1 bouyer printf("%s: selection timeout without "
564 1.1 bouyer "command\n", sc->sc_dev.dv_xname);
565 1.1 bouyer need_reset = 1;
566 1.1 bouyer }
567 1.1 bouyer }
568 1.21.2.5 he if (sist & SIST0_UDC) {
569 1.1 bouyer /*
570 1.1 bouyer * unexpected disconnect. Usually the target signals
571 1.1 bouyer * a fatal condition this way. Attempt to get sense.
572 1.1 bouyer */
573 1.21.2.5 he if (siop_cmd) {
574 1.21.2.5 he siop_cmd->siop_tables.status =
575 1.21.2.5 he htole32(SCSI_CHECK);
576 1.21.2.5 he goto end;
577 1.21.2.5 he }
578 1.1 bouyer printf("%s: unexpected disconnect without "
579 1.1 bouyer "command\n", sc->sc_dev.dv_xname);
580 1.2 bouyer goto reset;
581 1.1 bouyer }
582 1.21.2.5 he if (sist & (SIST1_SBMC << 8)) {
583 1.20 bouyer /* SCSI bus mode change */
584 1.20 bouyer if (siop_modechange(sc) == 0 || need_reset == 1)
585 1.20 bouyer goto reset;
586 1.20 bouyer if ((istat & ISTAT_DIP) && (dstat & DSTAT_SIR)) {
587 1.20 bouyer /*
588 1.20 bouyer * we have a script interrupt, it will
589 1.20 bouyer * restart the script.
590 1.20 bouyer */
591 1.20 bouyer goto scintr;
592 1.20 bouyer }
593 1.20 bouyer /*
594 1.20 bouyer * else we have to restart it ourselve, at the
595 1.20 bouyer * interrupted instruction.
596 1.20 bouyer */
597 1.20 bouyer bus_space_write_4(sc->sc_rt, sc->sc_rh, SIOP_DSP,
598 1.20 bouyer bus_space_read_4(sc->sc_rt, sc->sc_rh,
599 1.20 bouyer SIOP_DSP) - 8);
600 1.20 bouyer return 1;
601 1.20 bouyer }
602 1.1 bouyer /* Else it's an unhandled exeption (for now). */
603 1.21.2.5 he printf("%s: unhandled scsi interrupt, sist=0x%x sstat1=0x%x "
604 1.21.2.5 he "DSA=0x%x DSP=0x%x\n", sc->sc_dev.dv_xname, sist,
605 1.1 bouyer bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SSTAT1),
606 1.1 bouyer bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_DSA),
607 1.7 bouyer (int)(bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_DSP) -
608 1.17 bouyer sc->sc_scriptaddr));
609 1.1 bouyer if (siop_cmd) {
610 1.1 bouyer siop_cmd->status = CMDST_DONE;
611 1.1 bouyer xs->error = XS_SELTIMEOUT;
612 1.1 bouyer goto end;
613 1.1 bouyer }
614 1.1 bouyer need_reset = 1;
615 1.1 bouyer }
616 1.1 bouyer if (need_reset) {
617 1.1 bouyer reset:
618 1.1 bouyer /* fatal error, reset the bus */
619 1.21.2.2 bouyer siop_resetbus(sc);
620 1.2 bouyer /* no table to flush here */
621 1.1 bouyer return 1;
622 1.1 bouyer }
623 1.1 bouyer
624 1.20 bouyer scintr:
625 1.1 bouyer if ((istat & ISTAT_DIP) && (dstat & DSTAT_SIR)) { /* script interrupt */
626 1.1 bouyer irqcode = bus_space_read_4(sc->sc_rt, sc->sc_rh,
627 1.1 bouyer SIOP_DSPS);
628 1.21.2.5 he #ifdef SIOP_DEBUG_INTR
629 1.2 bouyer printf("script interrupt 0x%x\n", irqcode);
630 1.2 bouyer #endif
631 1.2 bouyer /*
632 1.21.2.5 he * no command, or an inactive command is only valid for a
633 1.21.2.5 he * reselect interrupt
634 1.2 bouyer */
635 1.21.2.5 he if ((irqcode & 0x80) == 0) {
636 1.21.2.5 he if (siop_cmd == NULL) {
637 1.21.2.5 he printf("%s: script interrupt (0x%x) with
638 1.21.2.5 he invalid DSA !!!\n", sc->sc_dev.dv_xname,
639 1.21.2.5 he irqcode);
640 1.21.2.5 he goto reset;
641 1.21.2.5 he }
642 1.21.2.5 he if (siop_cmd->status != CMDST_ACTIVE &&
643 1.21.2.5 he siop_cmd->status != CMDST_SENSE_ACTIVE) {
644 1.21.2.5 he printf("%s: command with invalid status "
645 1.21.2.5 he "(IRQ code 0x%x current status %d) !\n",
646 1.21.2.5 he sc->sc_dev.dv_xname,
647 1.21.2.5 he irqcode, siop_cmd->status);
648 1.21.2.5 he xs = NULL;
649 1.21.2.5 he }
650 1.7 bouyer }
651 1.1 bouyer switch(irqcode) {
652 1.1 bouyer case A_int_err:
653 1.2 bouyer printf("error, DSP=0x%x\n",
654 1.17 bouyer (int)(bus_space_read_4(sc->sc_rt, sc->sc_rh,
655 1.17 bouyer SIOP_DSP) - sc->sc_scriptaddr));
656 1.2 bouyer if (xs) {
657 1.2 bouyer xs->error = XS_SELTIMEOUT;
658 1.2 bouyer goto end;
659 1.2 bouyer } else {
660 1.2 bouyer goto reset;
661 1.2 bouyer }
662 1.21.2.5 he case A_int_reseltarg:
663 1.21.2.5 he printf("%s: reselect with invalid target\n",
664 1.21.2.5 he sc->sc_dev.dv_xname);
665 1.21.2.5 he goto reset;
666 1.21.2.5 he case A_int_resellun:
667 1.21.2.5 he INCSTAT(siop_stat_intr_lunresel);
668 1.21.2.5 he target = bus_space_read_1(sc->sc_rt, sc->sc_rh,
669 1.21.2.5 he SIOP_SCRATCHA) & 0xf;
670 1.21.2.5 he lun = bus_space_read_1(sc->sc_rt, sc->sc_rh,
671 1.21.2.5 he SIOP_SCRATCHA + 1);
672 1.21.2.5 he tag = bus_space_read_1(sc->sc_rt, sc->sc_rh,
673 1.21.2.5 he SIOP_SCRATCHA + 2);
674 1.21.2.5 he siop_target = sc->targets[target];
675 1.21.2.5 he if (siop_target == NULL) {
676 1.21.2.5 he printf("%s: reselect with invalid "
677 1.21.2.5 he "target %d\n", sc->sc_dev.dv_xname, target);
678 1.21.2.5 he goto reset;
679 1.21.2.5 he }
680 1.21.2.5 he siop_lun = siop_target->siop_lun[lun];
681 1.21.2.5 he if (siop_lun == NULL) {
682 1.21.2.5 he printf("%s: target %d reselect with invalid "
683 1.21.2.5 he "lun %d\n", sc->sc_dev.dv_xname,
684 1.21.2.5 he target, lun);
685 1.21.2.5 he goto reset;
686 1.21.2.5 he }
687 1.21.2.5 he if (siop_lun->siop_tag[tag].active == NULL) {
688 1.21.2.5 he printf("%s: target %d lun %d tag %d reselect "
689 1.21.2.5 he "without command\n", sc->sc_dev.dv_xname,
690 1.21.2.5 he target, lun, tag);
691 1.21.2.5 he goto reset;
692 1.21.2.5 he }
693 1.21.2.5 he siop_cmd = siop_lun->siop_tag[tag].active;
694 1.21.2.5 he bus_space_write_4(sc->sc_rt, sc->sc_rh, SIOP_DSP,
695 1.21.2.5 he siop_cmd->dsa + sizeof(struct siop_xfer_common) +
696 1.21.2.5 he Ent_ldsa_reload_dsa);
697 1.21.2.5 he return 1;
698 1.21.2.5 he case A_int_reseltag:
699 1.21.2.5 he printf("%s: reselect with invalid tag\n",
700 1.21.2.5 he sc->sc_dev.dv_xname);
701 1.21.2.5 he goto reset;
702 1.1 bouyer case A_int_msgin:
703 1.21.2.5 he {
704 1.21.2.5 he int msgin = bus_space_read_1(sc->sc_rt, sc->sc_rh,
705 1.21.2.5 he SIOP_SFBR);
706 1.21.2.5 he if (msgin == MSG_MESSAGE_REJECT) {
707 1.8 bouyer int msg, extmsg;
708 1.21.2.5 he if (siop_cmd->siop_tables.msg_out[0] & 0x80) {
709 1.8 bouyer /*
710 1.8 bouyer * message was part of a identify +
711 1.8 bouyer * something else. Identify shoudl't
712 1.8 bouyer * have been rejected.
713 1.8 bouyer */
714 1.21.2.5 he msg = siop_cmd->siop_tables.msg_out[1];
715 1.8 bouyer extmsg =
716 1.21.2.5 he siop_cmd->siop_tables.msg_out[3];
717 1.8 bouyer } else {
718 1.21.2.5 he msg = siop_cmd->siop_tables.msg_out[0];
719 1.8 bouyer extmsg =
720 1.21.2.5 he siop_cmd->siop_tables.msg_out[2];
721 1.8 bouyer }
722 1.8 bouyer if (msg == MSG_MESSAGE_REJECT) {
723 1.2 bouyer /* MSG_REJECT for a MSG_REJECT !*/
724 1.9 bouyer if (xs)
725 1.9 bouyer scsi_print_addr(xs->sc_link);
726 1.9 bouyer else
727 1.9 bouyer printf("%s: ",
728 1.9 bouyer sc->sc_dev.dv_xname);
729 1.9 bouyer printf("our reject message was "
730 1.9 bouyer "rejected\n");
731 1.2 bouyer goto reset;
732 1.2 bouyer }
733 1.8 bouyer if (msg == MSG_EXTENDED &&
734 1.8 bouyer extmsg == MSG_EXT_WDTR) {
735 1.9 bouyer /* WDTR rejected, initiate sync */
736 1.9 bouyer printf("%s: target %d using 8bit "
737 1.9 bouyer "transfers\n", sc->sc_dev.dv_xname,
738 1.21.2.5 he target);
739 1.21.2.5 he if ((siop_target->flags & TARF_SYNC)
740 1.21.2.5 he == 0) {
741 1.21.2.5 he siop_target->status = TARST_OK;
742 1.21.2.2 bouyer /* no table to flush here */
743 1.21.2.2 bouyer CALL_SCRIPT(Ent_msgin_ack);
744 1.21.2.2 bouyer return 1;
745 1.21.2.2 bouyer }
746 1.9 bouyer siop_target->status = TARST_SYNC_NEG;
747 1.21.2.5 he siop_sdtr_msg(siop_cmd, 0,
748 1.21.2.5 he sc->minsync, sc->maxoff);
749 1.9 bouyer siop_table_sync(siop_cmd,
750 1.9 bouyer BUS_DMASYNC_PREREAD |
751 1.9 bouyer BUS_DMASYNC_PREWRITE);
752 1.9 bouyer CALL_SCRIPT(Ent_send_msgout);
753 1.9 bouyer return 1;
754 1.8 bouyer } else if (msg == MSG_EXTENDED &&
755 1.8 bouyer extmsg == MSG_EXT_SDTR) {
756 1.7 bouyer /* sync rejected */
757 1.9 bouyer printf("%s: target %d asynchronous\n",
758 1.9 bouyer sc->sc_dev.dv_xname,
759 1.21.2.5 he target);
760 1.21.2.5 he siop_target->status = TARST_OK;
761 1.9 bouyer /* no table to flush here */
762 1.9 bouyer CALL_SCRIPT(Ent_msgin_ack);
763 1.9 bouyer return 1;
764 1.21.2.5 he } else if (msg == MSG_SIMPLE_Q_TAG ||
765 1.21.2.5 he msg == MSG_HEAD_OF_Q_TAG ||
766 1.21.2.5 he msg == MSG_ORDERED_Q_TAG) {
767 1.21.2.5 he if (siop_handle_qtag_reject(
768 1.21.2.5 he siop_cmd) == -1)
769 1.21.2.5 he goto reset;
770 1.21.2.5 he CALL_SCRIPT(Ent_msgin_ack);
771 1.21.2.5 he return 1;
772 1.9 bouyer }
773 1.9 bouyer if (xs)
774 1.9 bouyer scsi_print_addr(xs->sc_link);
775 1.9 bouyer else
776 1.9 bouyer printf("%s: ", sc->sc_dev.dv_xname);
777 1.9 bouyer if (msg == MSG_EXTENDED) {
778 1.9 bouyer printf("scsi message reject, extended "
779 1.9 bouyer "message sent was 0x%x\n", extmsg);
780 1.9 bouyer } else {
781 1.9 bouyer printf("scsi message reject, message "
782 1.9 bouyer "sent was 0x%x\n", msg);
783 1.7 bouyer }
784 1.2 bouyer /* no table to flush here */
785 1.2 bouyer CALL_SCRIPT(Ent_msgin_ack);
786 1.2 bouyer return 1;
787 1.2 bouyer }
788 1.9 bouyer if (xs)
789 1.9 bouyer scsi_print_addr(xs->sc_link);
790 1.9 bouyer else
791 1.9 bouyer printf("%s: ", sc->sc_dev.dv_xname);
792 1.8 bouyer printf("unhandled message 0x%x\n",
793 1.21.2.5 he siop_cmd->siop_tables.msg_in[0]);
794 1.21.2.5 he siop_cmd->siop_tables.msg_out[0] = MSG_MESSAGE_REJECT;
795 1.21.2.5 he siop_cmd->siop_tables.t_msgout.count= htole32(1);
796 1.2 bouyer siop_table_sync(siop_cmd,
797 1.2 bouyer BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
798 1.2 bouyer CALL_SCRIPT(Ent_send_msgout);
799 1.2 bouyer return 1;
800 1.21.2.5 he }
801 1.2 bouyer case A_int_extmsgin:
802 1.21.2.5 he #ifdef SIOP_DEBUG_INTR
803 1.2 bouyer printf("extended message: msg 0x%x len %d\n",
804 1.21.2.5 he siop_cmd->siop_tables.msg_in[2],
805 1.21.2.5 he siop_cmd->siop_tables.msg_in[1]);
806 1.2 bouyer #endif
807 1.21.2.5 he if (siop_cmd->siop_tables.msg_in[1] > 6)
808 1.8 bouyer printf("%s: extended message too big (%d)\n",
809 1.8 bouyer sc->sc_dev.dv_xname,
810 1.21.2.5 he siop_cmd->siop_tables.msg_in[1]);
811 1.21.2.5 he siop_cmd->siop_tables.t_extmsgdata.count =
812 1.21.2.5 he htole32(siop_cmd->siop_tables.msg_in[1] - 1);
813 1.2 bouyer siop_table_sync(siop_cmd,
814 1.2 bouyer BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
815 1.2 bouyer CALL_SCRIPT(Ent_get_extmsgdata);
816 1.2 bouyer return 1;
817 1.2 bouyer case A_int_extmsgdata:
818 1.21.2.5 he #ifdef SIOP_DEBUG_INTR
819 1.2 bouyer {
820 1.2 bouyer int i;
821 1.2 bouyer printf("extended message: 0x%x, data:",
822 1.21.2.5 he siop_cmd->siop_tables.msg_in[2]);
823 1.21.2.5 he for (i = 3; i < 2 + siop_cmd->siop_tables.msg_in[1];
824 1.2 bouyer i++)
825 1.2 bouyer printf(" 0x%x",
826 1.21.2.5 he siop_cmd->siop_tables.msg_in[i]);
827 1.2 bouyer printf("\n");
828 1.2 bouyer }
829 1.2 bouyer #endif
830 1.21.2.5 he if (siop_cmd->siop_tables.msg_in[2] == MSG_EXT_WDTR) {
831 1.14 bouyer switch (siop_wdtr_neg(siop_cmd)) {
832 1.14 bouyer case SIOP_NEG_MSGOUT:
833 1.21.2.5 he siop_update_scntl3(sc,
834 1.21.2.5 he siop_cmd->siop_target);
835 1.14 bouyer siop_table_sync(siop_cmd,
836 1.14 bouyer BUS_DMASYNC_PREREAD |
837 1.14 bouyer BUS_DMASYNC_PREWRITE);
838 1.14 bouyer CALL_SCRIPT(Ent_send_msgout);
839 1.21.2.5 he return(1);
840 1.21.2.2 bouyer case SIOP_NEG_ACK:
841 1.21.2.5 he siop_update_scntl3(sc,
842 1.21.2.5 he siop_cmd->siop_target);
843 1.21.2.2 bouyer CALL_SCRIPT(Ent_msgin_ack);
844 1.21.2.5 he return(1);
845 1.14 bouyer default:
846 1.14 bouyer panic("invalid retval from "
847 1.14 bouyer "siop_wdtr_neg()");
848 1.14 bouyer }
849 1.7 bouyer return(1);
850 1.7 bouyer }
851 1.21.2.5 he if (siop_cmd->siop_tables.msg_in[2] == MSG_EXT_SDTR) {
852 1.14 bouyer switch (siop_sdtr_neg(siop_cmd)) {
853 1.14 bouyer case SIOP_NEG_MSGOUT:
854 1.21.2.5 he siop_update_scntl3(sc,
855 1.21.2.5 he siop_cmd->siop_target);
856 1.14 bouyer siop_table_sync(siop_cmd,
857 1.14 bouyer BUS_DMASYNC_PREREAD |
858 1.14 bouyer BUS_DMASYNC_PREWRITE);
859 1.14 bouyer CALL_SCRIPT(Ent_send_msgout);
860 1.21.2.5 he return(1);
861 1.14 bouyer case SIOP_NEG_ACK:
862 1.21.2.5 he siop_update_scntl3(sc,
863 1.21.2.5 he siop_cmd->siop_target);
864 1.14 bouyer CALL_SCRIPT(Ent_msgin_ack);
865 1.21.2.5 he return(1);
866 1.14 bouyer default:
867 1.14 bouyer panic("invalid retval from "
868 1.14 bouyer "siop_wdtr_neg()");
869 1.14 bouyer }
870 1.7 bouyer return(1);
871 1.2 bouyer }
872 1.7 bouyer /* send a message reject */
873 1.21.2.5 he siop_cmd->siop_tables.msg_out[0] = MSG_MESSAGE_REJECT;
874 1.21.2.5 he siop_cmd->siop_tables.t_msgout.count = htole32(1);
875 1.2 bouyer siop_table_sync(siop_cmd,
876 1.2 bouyer BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
877 1.2 bouyer CALL_SCRIPT(Ent_send_msgout);
878 1.2 bouyer return 1;
879 1.1 bouyer case A_int_disc:
880 1.2 bouyer INCSTAT(siop_stat_intr_sdp);
881 1.1 bouyer offset = bus_space_read_1(sc->sc_rt, sc->sc_rh,
882 1.1 bouyer SIOP_SCRATCHA + 1);
883 1.21.2.5 he #ifdef SIOP_DEBUG_DR
884 1.1 bouyer printf("disconnect offset %d\n", offset);
885 1.1 bouyer #endif
886 1.1 bouyer if (offset > SIOP_NSG) {
887 1.1 bouyer printf("%s: bad offset for disconnect (%d)\n",
888 1.1 bouyer sc->sc_dev.dv_xname, offset);
889 1.1 bouyer goto reset;
890 1.1 bouyer }
891 1.1 bouyer /*
892 1.1 bouyer * offset == SIOP_NSG may be a valid condition if
893 1.1 bouyer * we get a sdp when the xfer is done.
894 1.1 bouyer * Don't call memmove in this case.
895 1.1 bouyer */
896 1.1 bouyer if (offset < SIOP_NSG) {
897 1.21.2.5 he memmove(&siop_cmd->siop_tables.data[0],
898 1.21.2.5 he &siop_cmd->siop_tables.data[offset],
899 1.1 bouyer (SIOP_NSG - offset) * sizeof(scr_table_t));
900 1.2 bouyer siop_table_sync(siop_cmd,
901 1.2 bouyer BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
902 1.1 bouyer }
903 1.21.2.5 he CALL_SCRIPT(Ent_script_sched);
904 1.21.2.5 he /* check if we can put some command in scheduler */
905 1.21.2.5 he siop_start(sc);
906 1.1 bouyer return 1;
907 1.1 bouyer case A_int_resfail:
908 1.1 bouyer printf("reselect failed\n");
909 1.21.2.5 he CALL_SCRIPT(Ent_script_sched);
910 1.1 bouyer return 1;
911 1.1 bouyer case A_int_done:
912 1.2 bouyer if (xs == NULL) {
913 1.8 bouyer printf("%s: done without command, DSA=0x%lx\n",
914 1.8 bouyer sc->sc_dev.dv_xname, (u_long)siop_cmd->dsa);
915 1.8 bouyer siop_cmd->status = CMDST_FREE;
916 1.2 bouyer siop_start(sc);
917 1.21.2.5 he CALL_SCRIPT(Ent_script_sched);
918 1.2 bouyer return 1;
919 1.2 bouyer }
920 1.21.2.5 he #ifdef SIOP_DEBUG_INTR
921 1.8 bouyer printf("done, DSA=0x%lx target id 0x%x last msg "
922 1.8 bouyer "in=0x%x status=0x%x\n", (u_long)siop_cmd->dsa,
923 1.21.2.5 he le32toh(siop_cmd->siop_tables.id),
924 1.21.2.5 he siop_cmd->siop_tables.msg_in[0],
925 1.21.2.5 he le32toh(siop_cmd->siop_tables.status));
926 1.1 bouyer #endif
927 1.2 bouyer INCSTAT(siop_stat_intr_done);
928 1.2 bouyer if (siop_cmd->status == CMDST_SENSE_ACTIVE)
929 1.1 bouyer siop_cmd->status = CMDST_SENSE_DONE;
930 1.1 bouyer else
931 1.1 bouyer siop_cmd->status = CMDST_DONE;
932 1.1 bouyer goto end;
933 1.1 bouyer default:
934 1.1 bouyer printf("unknown irqcode %x\n", irqcode);
935 1.21.2.5 he if (xs) {
936 1.21.2.5 he xs->error = XS_SELTIMEOUT;
937 1.21.2.5 he goto end;
938 1.21.2.5 he }
939 1.21.2.5 he goto reset;
940 1.1 bouyer }
941 1.1 bouyer return 1;
942 1.1 bouyer }
943 1.2 bouyer /* We just should't get there */
944 1.2 bouyer panic("siop_intr: I shouldn't be there !");
945 1.2 bouyer return 1;
946 1.1 bouyer end:
947 1.21.2.5 he CALL_SCRIPT(Ent_script_sched);
948 1.2 bouyer siop_scsicmd_end(siop_cmd);
949 1.21.2.5 he siop_lun->siop_tag[tag].active = NULL;
950 1.2 bouyer if (siop_cmd->status == CMDST_FREE) {
951 1.2 bouyer TAILQ_INSERT_TAIL(&sc->free_list, siop_cmd, next);
952 1.21.2.5 he siop_lun->lun_flags &= ~SIOP_LUNF_FULL;
953 1.21.2.5 he if (freetarget && siop_target->status == TARST_PROBING)
954 1.21.2.5 he siop_del_dev(sc, target, lun);
955 1.2 bouyer }
956 1.2 bouyer siop_start(sc);
957 1.2 bouyer return 1;
958 1.2 bouyer }
959 1.2 bouyer
960 1.2 bouyer void
961 1.2 bouyer siop_scsicmd_end(siop_cmd)
962 1.2 bouyer struct siop_cmd *siop_cmd;
963 1.2 bouyer {
964 1.2 bouyer struct scsipi_xfer *xs = siop_cmd->xs;
965 1.21.2.5 he struct siop_softc *sc = siop_cmd->siop_sc;
966 1.2 bouyer
967 1.21.2.5 he switch(le32toh(siop_cmd->siop_tables.status)) {
968 1.21.2.5 he case SCSI_OK:
969 1.21.2.5 he xs->error = (siop_cmd->status == CMDST_DONE) ?
970 1.21.2.5 he XS_NOERROR : XS_SENSE;
971 1.21.2.5 he break;
972 1.21.2.5 he case SCSI_BUSY:
973 1.21.2.5 he xs->error = XS_BUSY;
974 1.21.2.5 he break;
975 1.21.2.5 he case SCSI_CHECK:
976 1.21.2.5 he if (siop_cmd->status == CMDST_SENSE_DONE) {
977 1.21.2.5 he /* request sense on a request sense ? */
978 1.21.2.5 he printf("request sense failed\n");
979 1.21.2.5 he xs->error = XS_DRIVER_STUFFUP;
980 1.21.2.5 he } else {
981 1.21.2.5 he siop_cmd->status = CMDST_SENSE;
982 1.21.2.5 he }
983 1.21.2.5 he break;
984 1.21.2.5 he case SCSI_QUEUE_FULL:
985 1.21.2.5 he {
986 1.21.2.5 he struct siop_lun *siop_lun = siop_cmd->siop_target->siop_lun[
987 1.21.2.5 he xs->sc_link->scsipi_scsi.lun];
988 1.21.2.5 he /*
989 1.21.2.5 he * device didn't queue the command. We have to
990 1.21.2.5 he * retry it.
991 1.21.2.5 he * We insert it in the urgent list, hoping to preserve order.
992 1.21.2.5 he * But unfortunably, commands already in the scheduler may
993 1.21.2.5 he * be accepted before this one.
994 1.21.2.5 he * Also remember the condition, to avoid starting new commands
995 1.21.2.5 he * for this device before one is done.
996 1.21.2.5 he */
997 1.21.2.5 he INCSTAT(siop_stat_intr_qfull);
998 1.21.2.5 he #ifdef SIOP_DEBUG
999 1.21.2.5 he printf("%s:%d:%d: queue full (tag %d)\n", sc->sc_dev.dv_xname,
1000 1.21.2.5 he xs->sc_link->scsipi_scsi.target,
1001 1.21.2.5 he xs->sc_link->scsipi_scsi.lun, siop_cmd->tag);
1002 1.21.2.5 he #endif
1003 1.21.2.5 he callout_stop(&xs->xs_callout);
1004 1.21.2.5 he siop_lun->lun_flags |= SIOP_LUNF_FULL;
1005 1.21.2.5 he siop_cmd->status = CMDST_READY;
1006 1.21.2.5 he siop_setuptables(siop_cmd);
1007 1.21.2.5 he TAILQ_INSERT_TAIL(&sc->urgent_list, siop_cmd, next);
1008 1.21.2.5 he return;
1009 1.21.2.5 he }
1010 1.21.2.5 he case SCSI_SIOP_NOCHECK:
1011 1.21.2.5 he /*
1012 1.21.2.5 he * don't check status, xs->error is already valid
1013 1.21.2.5 he */
1014 1.21.2.5 he break;
1015 1.21.2.5 he case SCSI_SIOP_NOSTATUS:
1016 1.21.2.5 he /*
1017 1.21.2.5 he * the status byte was not updated, cmd was
1018 1.21.2.5 he * aborted
1019 1.21.2.5 he */
1020 1.21.2.5 he xs->error = XS_SELTIMEOUT;
1021 1.21.2.5 he break;
1022 1.21.2.5 he default:
1023 1.21.2.5 he xs->error = XS_DRIVER_STUFFUP;
1024 1.21.2.5 he }
1025 1.1 bouyer if (siop_cmd->status != CMDST_SENSE_DONE &&
1026 1.1 bouyer xs->xs_control & (XS_CTL_DATA_IN | XS_CTL_DATA_OUT)) {
1027 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, siop_cmd->dmamap_data, 0,
1028 1.1 bouyer siop_cmd->dmamap_data->dm_mapsize,
1029 1.1 bouyer (xs->xs_control & XS_CTL_DATA_IN) ?
1030 1.1 bouyer BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
1031 1.1 bouyer bus_dmamap_unload(sc->sc_dmat, siop_cmd->dmamap_data);
1032 1.1 bouyer }
1033 1.1 bouyer bus_dmamap_unload(sc->sc_dmat, siop_cmd->dmamap_cmd);
1034 1.1 bouyer if (siop_cmd->status == CMDST_SENSE) {
1035 1.1 bouyer /* issue a request sense for this target */
1036 1.21.2.5 he int error;
1037 1.1 bouyer siop_cmd->rs_cmd.opcode = REQUEST_SENSE;
1038 1.1 bouyer siop_cmd->rs_cmd.byte2 = xs->sc_link->scsipi_scsi.lun << 5;
1039 1.1 bouyer siop_cmd->rs_cmd.unused[0] = siop_cmd->rs_cmd.unused[1] = 0;
1040 1.1 bouyer siop_cmd->rs_cmd.length = sizeof(struct scsipi_sense_data);
1041 1.1 bouyer siop_cmd->rs_cmd.control = 0;
1042 1.21.2.5 he siop_cmd->flags &= ~CMDFL_TAG;
1043 1.1 bouyer error = bus_dmamap_load(sc->sc_dmat, siop_cmd->dmamap_cmd,
1044 1.1 bouyer &siop_cmd->rs_cmd, sizeof(struct scsipi_sense),
1045 1.1 bouyer NULL, BUS_DMA_NOWAIT);
1046 1.1 bouyer if (error) {
1047 1.1 bouyer printf("%s: unable to load cmd DMA map: %d",
1048 1.1 bouyer sc->sc_dev.dv_xname, error);
1049 1.1 bouyer xs->error = XS_DRIVER_STUFFUP;
1050 1.1 bouyer goto out;
1051 1.1 bouyer }
1052 1.1 bouyer error = bus_dmamap_load(sc->sc_dmat, siop_cmd->dmamap_data,
1053 1.1 bouyer &xs->sense.scsi_sense, sizeof(struct scsipi_sense_data),
1054 1.1 bouyer NULL, BUS_DMA_NOWAIT);
1055 1.1 bouyer if (error) {
1056 1.1 bouyer printf("%s: unable to load sense DMA map: %d",
1057 1.1 bouyer sc->sc_dev.dv_xname, error);
1058 1.1 bouyer xs->error = XS_DRIVER_STUFFUP;
1059 1.1 bouyer bus_dmamap_unload(sc->sc_dmat, siop_cmd->dmamap_cmd);
1060 1.1 bouyer goto out;
1061 1.1 bouyer }
1062 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, siop_cmd->dmamap_data, 0,
1063 1.1 bouyer siop_cmd->dmamap_data->dm_mapsize, BUS_DMASYNC_PREREAD);
1064 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, siop_cmd->dmamap_cmd, 0,
1065 1.1 bouyer siop_cmd->dmamap_cmd->dm_mapsize, BUS_DMASYNC_PREWRITE);
1066 1.21.2.5 he
1067 1.21.2.5 he siop_setuptables(siop_cmd);
1068 1.21.2.5 he /* arrange for the cmd to be handled now */
1069 1.21.2.5 he TAILQ_INSERT_HEAD(&sc->urgent_list, siop_cmd, next);
1070 1.2 bouyer return;
1071 1.1 bouyer } else if (siop_cmd->status == CMDST_SENSE_DONE) {
1072 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, siop_cmd->dmamap_data, 0,
1073 1.1 bouyer siop_cmd->dmamap_data->dm_mapsize, BUS_DMASYNC_POSTREAD);
1074 1.1 bouyer bus_dmamap_unload(sc->sc_dmat, siop_cmd->dmamap_data);
1075 1.1 bouyer }
1076 1.1 bouyer out:
1077 1.1 bouyer callout_stop(&siop_cmd->xs->xs_callout);
1078 1.1 bouyer siop_cmd->status = CMDST_FREE;
1079 1.1 bouyer xs->xs_status |= XS_STS_DONE;
1080 1.1 bouyer xs->resid = 0;
1081 1.14 bouyer if ((xs->xs_control & XS_CTL_POLL) == 0)
1082 1.14 bouyer scsipi_done (xs);
1083 1.7 bouyer }
1084 1.7 bouyer
1085 1.2 bouyer /*
1086 1.21.2.5 he * handle a rejected queue tag message: the command will run untagged,
1087 1.21.2.5 he * has to adjust the reselect script.
1088 1.21.2.5 he */
1089 1.21.2.5 he int
1090 1.21.2.5 he siop_handle_qtag_reject(siop_cmd)
1091 1.21.2.5 he struct siop_cmd *siop_cmd;
1092 1.21.2.5 he {
1093 1.21.2.5 he struct siop_softc *sc = siop_cmd->siop_sc;
1094 1.21.2.5 he int target = siop_cmd->xs->sc_link->scsipi_scsi.target;
1095 1.21.2.5 he int lun = siop_cmd->xs->sc_link->scsipi_scsi.lun;
1096 1.21.2.5 he int tag = siop_cmd->siop_tables.msg_out[2];
1097 1.21.2.5 he struct siop_lun *siop_lun = sc->targets[target]->siop_lun[lun];
1098 1.21.2.5 he
1099 1.21.2.5 he #ifdef SIOP_DEBUG
1100 1.21.2.5 he printf("%s:%d:%d: tag message %d (%d) rejected (status %d)\n",
1101 1.21.2.5 he sc->sc_dev.dv_xname, target, lun, tag, siop_cmd->tag,
1102 1.21.2.5 he siop_cmd->status);
1103 1.21.2.5 he #endif
1104 1.21.2.5 he
1105 1.21.2.5 he if (siop_lun->siop_tag[0].active != NULL) {
1106 1.21.2.5 he printf("%s: untagged command already running for target %d "
1107 1.21.2.5 he "lun %d (status %d)\n", sc->sc_dev.dv_xname, target, lun,
1108 1.21.2.5 he siop_lun->siop_tag[0].active->status);
1109 1.21.2.5 he return -1;
1110 1.21.2.5 he }
1111 1.21.2.5 he /* clear tag slot */
1112 1.21.2.5 he siop_lun->siop_tag[tag].active = NULL;
1113 1.21.2.5 he /* add command to non-tagged slot */
1114 1.21.2.5 he siop_lun->siop_tag[0].active = siop_cmd;
1115 1.21.2.5 he siop_cmd->tag = 0;
1116 1.21.2.5 he /* adjust reselect script if there is one */
1117 1.21.2.5 he if (siop_lun->siop_tag[0].reseloff > 0) {
1118 1.21.2.5 he siop_script_write(sc,
1119 1.21.2.5 he siop_lun->siop_tag[0].reseloff + 1,
1120 1.21.2.5 he siop_cmd->dsa + sizeof(struct siop_xfer_common) +
1121 1.21.2.5 he Ent_ldsa_reload_dsa);
1122 1.21.2.5 he }
1123 1.21.2.5 he return 0;
1124 1.21.2.5 he }
1125 1.21.2.5 he
1126 1.21.2.5 he /*
1127 1.21.2.5 he * handle a bus reset: reset chip, unqueue all active commands, free all
1128 1.21.2.5 he * target struct and report loosage to upper layer.
1129 1.2 bouyer * As the upper layer may requeue immediatly we have to first store
1130 1.2 bouyer * all active commands in a temporary queue.
1131 1.2 bouyer */
1132 1.2 bouyer void
1133 1.2 bouyer siop_handle_reset(sc)
1134 1.2 bouyer struct siop_softc *sc;
1135 1.2 bouyer {
1136 1.2 bouyer struct cmd_list reset_list;
1137 1.2 bouyer struct siop_cmd *siop_cmd, *next_siop_cmd;
1138 1.21.2.5 he struct siop_lun *siop_lun;
1139 1.21.2.5 he int target, lun, tag;
1140 1.2 bouyer /*
1141 1.2 bouyer * scsi bus reset. reset the chip and restart
1142 1.2 bouyer * the queue. Need to clean up all active commands
1143 1.2 bouyer */
1144 1.2 bouyer printf("%s: scsi bus reset\n", sc->sc_dev.dv_xname);
1145 1.2 bouyer /* stop, reset and restart the chip */
1146 1.2 bouyer siop_reset(sc);
1147 1.2 bouyer TAILQ_INIT(&reset_list);
1148 1.21.2.5 he /*
1149 1.21.2.5 he * Process all commands: first commmands being executed
1150 1.21.2.5 he */
1151 1.21.2.4 bouyer for (target = 0; target <= sc->sc_link.scsipi_scsi.max_target;
1152 1.7 bouyer target++) {
1153 1.7 bouyer if (sc->targets[target] == NULL)
1154 1.7 bouyer continue;
1155 1.7 bouyer for (lun = 0; lun < 8; lun++) {
1156 1.21.2.5 he siop_lun = sc->targets[target]->siop_lun[lun];
1157 1.21.2.5 he if (siop_lun == NULL)
1158 1.21.2.5 he continue;
1159 1.21.2.5 he siop_lun->lun_flags &= ~SIOP_LUNF_FULL;
1160 1.21.2.5 he for (tag = 0; tag <
1161 1.21.2.5 he ((sc->targets[target]->flags & TARF_TAG) ?
1162 1.21.2.5 he SIOP_NTAG : 1);
1163 1.21.2.5 he tag++) {
1164 1.21.2.5 he siop_cmd = siop_lun->siop_tag[tag].active;
1165 1.21.2.5 he if (siop_cmd == NULL)
1166 1.7 bouyer continue;
1167 1.21.2.5 he printf("cmd %p (target %d:%d) in reset list\n",
1168 1.21.2.5 he siop_cmd, target, lun);
1169 1.7 bouyer TAILQ_INSERT_TAIL(&reset_list, siop_cmd, next);
1170 1.21.2.5 he siop_lun->siop_tag[tag].active = NULL;
1171 1.7 bouyer }
1172 1.2 bouyer }
1173 1.7 bouyer sc->targets[target]->status = TARST_ASYNC;
1174 1.21.2.5 he sc->targets[target]->flags &= ~TARF_ISWIDE;
1175 1.2 bouyer }
1176 1.21.2.5 he /* Next commands from the urgent list */
1177 1.21.2.5 he for (siop_cmd = TAILQ_FIRST(&sc->urgent_list); siop_cmd != NULL;
1178 1.21.2.5 he siop_cmd = next_siop_cmd) {
1179 1.21.2.5 he next_siop_cmd = TAILQ_NEXT(siop_cmd, next);
1180 1.21.2.5 he siop_cmd->flags &= ~CMDFL_TAG;
1181 1.21.2.5 he printf("cmd %p (target %d:%d) in reset list (wait)\n",
1182 1.21.2.5 he siop_cmd, siop_cmd->xs->sc_link->scsipi_scsi.target,
1183 1.21.2.5 he siop_cmd->xs->sc_link->scsipi_scsi.lun);
1184 1.21.2.5 he TAILQ_REMOVE(&sc->urgent_list, siop_cmd, next);
1185 1.21.2.5 he TAILQ_INSERT_TAIL(&reset_list, siop_cmd, next);
1186 1.21.2.5 he }
1187 1.21.2.5 he /* Then command waiting in the input list */
1188 1.21.2.5 he for (siop_cmd = TAILQ_FIRST(&sc->ready_list); siop_cmd != NULL;
1189 1.21.2.5 he siop_cmd = next_siop_cmd) {
1190 1.21.2.5 he next_siop_cmd = TAILQ_NEXT(siop_cmd, next);
1191 1.21.2.5 he siop_cmd->flags &= ~CMDFL_TAG;
1192 1.21.2.5 he printf("cmd %p (target %d:%d) in reset list (wait)\n",
1193 1.21.2.5 he siop_cmd, siop_cmd->xs->sc_link->scsipi_scsi.target,
1194 1.21.2.5 he siop_cmd->xs->sc_link->scsipi_scsi.lun);
1195 1.21.2.5 he TAILQ_REMOVE(&sc->ready_list, siop_cmd, next);
1196 1.21.2.5 he TAILQ_INSERT_TAIL(&reset_list, siop_cmd, next);
1197 1.21.2.5 he }
1198 1.21.2.5 he
1199 1.2 bouyer for (siop_cmd = TAILQ_FIRST(&reset_list); siop_cmd != NULL;
1200 1.2 bouyer siop_cmd = next_siop_cmd) {
1201 1.2 bouyer next_siop_cmd = TAILQ_NEXT(siop_cmd, next);
1202 1.2 bouyer siop_cmd->xs->error = (siop_cmd->flags & CMDFL_TIMEOUT) ?
1203 1.2 bouyer XS_TIMEOUT : XS_RESET;
1204 1.21.2.5 he siop_cmd->siop_tables.status = htole32(SCSI_SIOP_NOCHECK);
1205 1.21.2.5 he printf("cmd %p (status %d) about to be processed\n", siop_cmd,
1206 1.21.2.5 he siop_cmd->status);
1207 1.16 bouyer if (siop_cmd->status == CMDST_SENSE ||
1208 1.16 bouyer siop_cmd->status == CMDST_SENSE_ACTIVE)
1209 1.16 bouyer siop_cmd->status = CMDST_SENSE_DONE;
1210 1.16 bouyer else
1211 1.16 bouyer siop_cmd->status = CMDST_DONE;
1212 1.2 bouyer TAILQ_REMOVE(&reset_list, siop_cmd, next);
1213 1.2 bouyer siop_scsicmd_end(siop_cmd);
1214 1.2 bouyer TAILQ_INSERT_TAIL(&sc->free_list, siop_cmd, next);
1215 1.2 bouyer }
1216 1.1 bouyer }
1217 1.1 bouyer
1218 1.2 bouyer int
1219 1.1 bouyer siop_scsicmd(xs)
1220 1.1 bouyer struct scsipi_xfer *xs;
1221 1.1 bouyer {
1222 1.1 bouyer struct siop_softc *sc = (struct siop_softc *)xs->sc_link->adapter_softc;
1223 1.1 bouyer struct siop_cmd *siop_cmd;
1224 1.1 bouyer int s, error, i;
1225 1.21.2.5 he const int target = xs->sc_link->scsipi_scsi.target;
1226 1.21.2.5 he const int lun = xs->sc_link->scsipi_scsi.lun;
1227 1.1 bouyer
1228 1.1 bouyer s = splbio();
1229 1.21.2.5 he #ifdef SIOP_DEBUG_SCHED
1230 1.7 bouyer printf("starting cmd for %d:%d\n", target, lun);
1231 1.1 bouyer #endif
1232 1.21.2.5 he siop_cmd = TAILQ_FIRST(&sc->free_list);
1233 1.1 bouyer if (siop_cmd) {
1234 1.1 bouyer TAILQ_REMOVE(&sc->free_list, siop_cmd, next);
1235 1.16 bouyer } else {
1236 1.16 bouyer if (siop_morecbd(sc) == 0) {
1237 1.21.2.5 he siop_cmd = TAILQ_FIRST(&sc->free_list);
1238 1.16 bouyer #ifdef DIAGNOSTIC
1239 1.16 bouyer if (siop_cmd == NULL)
1240 1.16 bouyer panic("siop_morecbd succeed and does nothing");
1241 1.16 bouyer #endif
1242 1.16 bouyer TAILQ_REMOVE(&sc->free_list, siop_cmd, next);
1243 1.16 bouyer }
1244 1.1 bouyer }
1245 1.1 bouyer if (siop_cmd == NULL) {
1246 1.1 bouyer xs->error = XS_DRIVER_STUFFUP;
1247 1.21.2.5 he splx(s);
1248 1.1 bouyer return(TRY_AGAIN_LATER);
1249 1.1 bouyer }
1250 1.1 bouyer #ifdef DIAGNOSTIC
1251 1.1 bouyer if (siop_cmd->status != CMDST_FREE)
1252 1.1 bouyer panic("siop_scsicmd: new cmd not free");
1253 1.1 bouyer #endif
1254 1.7 bouyer if (sc->targets[target] == NULL) {
1255 1.21.2.5 he #ifdef SIOP_DEBUG
1256 1.21.2.5 he printf("%s: alloc siop_target for target %d\n",
1257 1.21.2.5 he sc->sc_dev.dv_xname, target);
1258 1.21.2.5 he #endif
1259 1.7 bouyer sc->targets[target] =
1260 1.7 bouyer malloc(sizeof(struct siop_target), M_DEVBUF, M_NOWAIT);
1261 1.7 bouyer if (sc->targets[target] == NULL) {
1262 1.7 bouyer printf("%s: can't malloc memory for target %d\n",
1263 1.7 bouyer sc->sc_dev.dv_xname, target);
1264 1.7 bouyer xs->error = XS_DRIVER_STUFFUP;
1265 1.21.2.5 he splx(s);
1266 1.7 bouyer return(TRY_AGAIN_LATER);
1267 1.7 bouyer }
1268 1.7 bouyer sc->targets[target]->status = TARST_PROBING;
1269 1.7 bouyer sc->targets[target]->flags = 0;
1270 1.7 bouyer sc->targets[target]->id = sc->clock_div << 24; /* scntl3 */
1271 1.7 bouyer sc->targets[target]->id |= target << 16; /* id */
1272 1.14 bouyer /* sc->targets[target]->id |= 0x0 << 8; scxfer is 0 */
1273 1.21.2.5 he
1274 1.21.2.5 he /* get a lun switch script */
1275 1.21.2.5 he sc->targets[target]->lunsw = siop_get_lunsw(sc);
1276 1.21.2.5 he if (sc->targets[target]->lunsw == NULL) {
1277 1.21.2.5 he printf("%s: can't alloc lunsw for target %d\n",
1278 1.21.2.5 he sc->sc_dev.dv_xname, target);
1279 1.21.2.5 he xs->error = XS_DRIVER_STUFFUP;
1280 1.21.2.5 he splx(s);
1281 1.21.2.5 he return(TRY_AGAIN_LATER);
1282 1.21.2.5 he }
1283 1.21.2.5 he for (i=0; i < 8; i++)
1284 1.21.2.5 he sc->targets[target]->siop_lun[i] = NULL;
1285 1.21.2.5 he siop_add_reselsw(sc, target);
1286 1.21.2.5 he }
1287 1.21.2.5 he if (sc->targets[target]->siop_lun[lun] == NULL) {
1288 1.21.2.5 he sc->targets[target]->siop_lun[lun] =
1289 1.21.2.5 he malloc(sizeof(struct siop_lun), M_DEVBUF, M_NOWAIT);
1290 1.21.2.5 he if (sc->targets[target]->siop_lun[lun] == NULL) {
1291 1.21.2.5 he printf("%s: can't alloc siop_lun for target %d "
1292 1.21.2.5 he "lun %d\n", sc->sc_dev.dv_xname, target, lun);
1293 1.21.2.5 he xs->error = XS_DRIVER_STUFFUP;
1294 1.21.2.5 he splx(s);
1295 1.21.2.5 he return(TRY_AGAIN_LATER);
1296 1.21.2.5 he }
1297 1.21.2.5 he memset(sc->targets[target]->siop_lun[lun], 0,
1298 1.21.2.5 he sizeof(struct siop_lun));
1299 1.7 bouyer }
1300 1.7 bouyer siop_cmd->siop_target = sc->targets[target];
1301 1.1 bouyer siop_cmd->xs = xs;
1302 1.21.2.5 he siop_cmd->flags = 0;
1303 1.21.2.5 he siop_cmd->status = CMDST_READY;
1304 1.1 bouyer
1305 1.1 bouyer /* load the DMA maps */
1306 1.1 bouyer error = bus_dmamap_load(sc->sc_dmat, siop_cmd->dmamap_cmd,
1307 1.1 bouyer xs->cmd, xs->cmdlen, NULL, BUS_DMA_NOWAIT);
1308 1.1 bouyer if (error) {
1309 1.1 bouyer printf("%s: unable to load cmd DMA map: %d",
1310 1.1 bouyer sc->sc_dev.dv_xname, error);
1311 1.1 bouyer xs->error = XS_DRIVER_STUFFUP;
1312 1.21.2.5 he splx(s);
1313 1.1 bouyer return(TRY_AGAIN_LATER);
1314 1.1 bouyer }
1315 1.1 bouyer if (xs->xs_control & (XS_CTL_DATA_IN | XS_CTL_DATA_OUT)) {
1316 1.1 bouyer error = bus_dmamap_load(sc->sc_dmat, siop_cmd->dmamap_data,
1317 1.1 bouyer xs->data, xs->datalen, NULL, BUS_DMA_NOWAIT);
1318 1.1 bouyer if (error) {
1319 1.1 bouyer printf("%s: unable to load cmd DMA map: %d",
1320 1.1 bouyer sc->sc_dev.dv_xname, error);
1321 1.1 bouyer xs->error = XS_DRIVER_STUFFUP;
1322 1.1 bouyer bus_dmamap_unload(sc->sc_dmat, siop_cmd->dmamap_cmd);
1323 1.21.2.5 he splx(s);
1324 1.21.2.5 he return(TRY_AGAIN_LATER);
1325 1.1 bouyer }
1326 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, siop_cmd->dmamap_data, 0,
1327 1.1 bouyer siop_cmd->dmamap_data->dm_mapsize,
1328 1.1 bouyer (xs->xs_control & XS_CTL_DATA_IN) ?
1329 1.1 bouyer BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
1330 1.1 bouyer }
1331 1.1 bouyer bus_dmamap_sync(sc->sc_dmat, siop_cmd->dmamap_cmd, 0,
1332 1.1 bouyer siop_cmd->dmamap_cmd->dm_mapsize, BUS_DMASYNC_PREWRITE);
1333 1.1 bouyer
1334 1.21.2.5 he siop_setuptables(siop_cmd);
1335 1.21.2.5 he
1336 1.21.2.5 he TAILQ_INSERT_TAIL(&sc->ready_list, siop_cmd, next);
1337 1.2 bouyer siop_start(sc);
1338 1.14 bouyer if (xs->xs_control & XS_CTL_POLL) {
1339 1.14 bouyer /* poll for command completion */
1340 1.21.2.5 he while ((xs->xs_status & XS_STS_DONE) == 0) {
1341 1.21.2.5 he delay(1000);
1342 1.14 bouyer siop_intr(sc);
1343 1.21.2.5 he }
1344 1.14 bouyer splx(s);
1345 1.14 bouyer return (COMPLETE);
1346 1.14 bouyer }
1347 1.1 bouyer splx(s);
1348 1.1 bouyer return (SUCCESSFULLY_QUEUED);
1349 1.1 bouyer }
1350 1.1 bouyer
1351 1.1 bouyer void
1352 1.1 bouyer siop_start(sc)
1353 1.1 bouyer struct siop_softc *sc;
1354 1.1 bouyer {
1355 1.21.2.5 he struct siop_cmd *siop_cmd, *next_siop_cmd;
1356 1.21.2.5 he struct siop_lun *siop_lun;
1357 1.2 bouyer u_int32_t dsa;
1358 1.1 bouyer int timeout;
1359 1.21.2.5 he int target, lun, tag, slot;
1360 1.2 bouyer int newcmd = 0;
1361 1.21.2.5 he int doingready = 0;
1362 1.2 bouyer
1363 1.2 bouyer /*
1364 1.2 bouyer * first make sure to read valid data
1365 1.2 bouyer */
1366 1.21.2.5 he siop_script_sync(sc, BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1367 1.1 bouyer
1368 1.2 bouyer /*
1369 1.10 bouyer * The queue management here is a bit tricky: the script always looks
1370 1.10 bouyer * at the slot from first to last, so if we always use the first
1371 1.10 bouyer * free slot commands can stay at the tail of the queue ~forever.
1372 1.10 bouyer * The algorithm used here is to restart from the head when we know
1373 1.10 bouyer * that the queue is empty, and only add commands after the last one.
1374 1.10 bouyer * When we're at the end of the queue wait for the script to clear it.
1375 1.10 bouyer * The best thing to do here would be to implement a circular queue,
1376 1.10 bouyer * but using only 53c720 features this can be "interesting".
1377 1.10 bouyer * A mid-way solution could be to implement 2 queues and swap orders.
1378 1.2 bouyer */
1379 1.21.2.5 he slot = sc->sc_currschedslot;
1380 1.10 bouyer /*
1381 1.21.2.5 he * If the instruction is 0x80000000 (JUMP foo, IF FALSE) the slot is
1382 1.21.2.5 he * free. As this is the last used slot, all previous slots are free,
1383 1.21.2.5 he * we can restart from 0.
1384 1.10 bouyer */
1385 1.21.2.5 he if (siop_script_read(sc, (Ent_script_sched_slot0 / 4) + slot * 2) ==
1386 1.21.2.5 he 0x80000000) {
1387 1.21.2.5 he slot = sc->sc_currschedslot = 0;
1388 1.10 bouyer } else {
1389 1.10 bouyer slot++;
1390 1.10 bouyer }
1391 1.21.2.5 he /* first handle commands from the urgent list */
1392 1.21.2.5 he siop_cmd = TAILQ_FIRST(&sc->urgent_list);
1393 1.21.2.5 he again:
1394 1.21.2.5 he for (; siop_cmd != NULL; siop_cmd = next_siop_cmd) {
1395 1.21.2.5 he next_siop_cmd = TAILQ_NEXT(siop_cmd, next);
1396 1.21.2.5 he #ifdef DIAGNOSTIC
1397 1.21.2.5 he if (siop_cmd->status != CMDST_READY &&
1398 1.21.2.5 he siop_cmd->status != CMDST_SENSE)
1399 1.21.2.5 he panic("siop: non-ready cmd in ready list");
1400 1.21.2.5 he #endif
1401 1.21.2.5 he target = siop_cmd->xs->sc_link->scsipi_scsi.target;
1402 1.21.2.5 he lun = siop_cmd->xs->sc_link->scsipi_scsi.lun;
1403 1.21.2.5 he siop_lun = sc->targets[target]->siop_lun[lun];
1404 1.21.2.5 he /* if non-tagged command active, wait */
1405 1.21.2.5 he if (siop_lun->siop_tag[0].active != NULL)
1406 1.2 bouyer continue;
1407 1.21.2.5 he /*
1408 1.21.2.5 he * if we're in a queue full condition don't start a new
1409 1.21.2.5 he * command, unless it's a request sense
1410 1.21.2.5 he */
1411 1.21.2.5 he if ((siop_lun->lun_flags & SIOP_LUNF_FULL) &&
1412 1.21.2.5 he siop_cmd->status == CMDST_READY)
1413 1.21.2.5 he continue;
1414 1.21.2.5 he /* find a free tag if needed */
1415 1.21.2.5 he if (siop_cmd->flags & CMDFL_TAG) {
1416 1.21.2.5 he for (tag = 1; tag < SIOP_NTAG; tag++) {
1417 1.21.2.5 he if (siop_lun->siop_tag[tag].active == NULL)
1418 1.21.2.5 he break;
1419 1.21.2.5 he }
1420 1.21.2.5 he if (tag == SIOP_NTAG) /* no free tag */
1421 1.2 bouyer continue;
1422 1.21.2.5 he } else {
1423 1.21.2.5 he tag = 0;
1424 1.21.2.5 he }
1425 1.21.2.5 he siop_cmd->tag = tag;
1426 1.21.2.5 he /* find a free scheduler slot and load it */
1427 1.21.2.5 he for (; slot < SIOP_NSLOTS; slot++) {
1428 1.21.2.5 he /*
1429 1.21.2.5 he * If cmd if 0x80000000 the slot is free
1430 1.21.2.5 he */
1431 1.21.2.5 he if (siop_script_read(sc,
1432 1.21.2.5 he (Ent_script_sched_slot0 / 4) + slot * 2) ==
1433 1.21.2.5 he 0x80000000)
1434 1.7 bouyer break;
1435 1.21.2.5 he }
1436 1.21.2.5 he /* no more free slot, no need to continue */
1437 1.21.2.5 he if (slot == SIOP_NSLOTS) {
1438 1.21.2.5 he goto end;
1439 1.21.2.5 he }
1440 1.21.2.5 he #ifdef SIOP_DEBUG_SCHED
1441 1.21.2.5 he printf("using slot %d for DSA 0x%lx\n", slot,
1442 1.21.2.5 he (u_long)siop_cmd->dsa);
1443 1.21.2.5 he #endif
1444 1.21.2.5 he /* Ok, we can add the tag message */
1445 1.21.2.5 he if (tag > 0) {
1446 1.21.2.5 he #ifdef DIAGNOSTIC
1447 1.21.2.5 he int msgcount =
1448 1.21.2.5 he le32toh(siop_cmd->siop_tables.t_msgout.count);
1449 1.21.2.5 he if (msgcount != 1)
1450 1.21.2.5 he printf("%s:%d:%d: tag %d with msgcount %d\n",
1451 1.21.2.5 he sc->sc_dev.dv_xname, target, lun, tag,
1452 1.21.2.5 he msgcount);
1453 1.21.2.5 he #endif
1454 1.21.2.5 he if (siop_cmd->xs->bp != NULL &&
1455 1.21.2.5 he (siop_cmd->xs->bp->b_flags & B_ASYNC))
1456 1.21.2.5 he siop_cmd->siop_tables.msg_out[1] =
1457 1.21.2.5 he MSG_SIMPLE_Q_TAG;
1458 1.21.2.5 he else
1459 1.21.2.5 he siop_cmd->siop_tables.msg_out[1] =
1460 1.21.2.5 he MSG_ORDERED_Q_TAG;
1461 1.21.2.5 he siop_cmd->siop_tables.msg_out[2] = tag;
1462 1.21.2.5 he siop_cmd->siop_tables.t_msgout.count = htole32(3);
1463 1.21.2.5 he }
1464 1.21.2.5 he /* note that we started a new command */
1465 1.21.2.5 he newcmd = 1;
1466 1.21.2.5 he /* mark command as active */
1467 1.21.2.5 he if (siop_cmd->status == CMDST_READY) {
1468 1.21.2.5 he siop_cmd->status = CMDST_ACTIVE;
1469 1.21.2.5 he } else if (siop_cmd->status == CMDST_SENSE) {
1470 1.21.2.5 he siop_cmd->status = CMDST_SENSE_ACTIVE;
1471 1.21.2.5 he } else
1472 1.21.2.5 he panic("siop_start: bad status");
1473 1.21.2.5 he if (doingready)
1474 1.21.2.5 he TAILQ_REMOVE(&sc->ready_list, siop_cmd, next);
1475 1.21.2.5 he else
1476 1.21.2.5 he TAILQ_REMOVE(&sc->urgent_list, siop_cmd, next);
1477 1.21.2.5 he siop_lun->siop_tag[tag].active = siop_cmd;
1478 1.21.2.5 he /* patch scripts with DSA addr */
1479 1.21.2.5 he dsa = siop_cmd->dsa;
1480 1.21.2.5 he /* first reselect switch, if we have an entry */
1481 1.21.2.5 he if (siop_lun->siop_tag[tag].reseloff > 0)
1482 1.21.2.5 he siop_script_write(sc,
1483 1.21.2.5 he siop_lun->siop_tag[tag].reseloff + 1,
1484 1.21.2.5 he dsa + sizeof(struct siop_xfer_common) +
1485 1.21.2.5 he Ent_ldsa_reload_dsa);
1486 1.21.2.5 he /* CMD script: MOVE MEMORY addr */
1487 1.21.2.5 he siop_cmd->siop_xfer->resel[E_ldsa_abs_slot_Used[0]] =
1488 1.21.2.5 he htole32(sc->sc_scriptaddr + Ent_script_sched_slot0 +
1489 1.21.2.5 he slot * 8);
1490 1.21.2.5 he /* scheduler slot: JUMP ldsa_select */
1491 1.21.2.5 he siop_script_write(sc,
1492 1.21.2.5 he (Ent_script_sched_slot0 / 4) + slot * 2 + 1,
1493 1.21.2.5 he dsa + sizeof(struct siop_xfer_common) + Ent_ldsa_select);
1494 1.21.2.5 he /* handle timeout */
1495 1.21.2.5 he if (siop_cmd->status == CMDST_ACTIVE) {
1496 1.21.2.5 he if ((siop_cmd->xs->xs_control &
1497 1.21.2.5 he XS_CTL_POLL) == 0) {
1498 1.21.2.5 he /* start exire timer */
1499 1.21.2.5 he timeout = (u_int64_t) siop_cmd->xs->timeout *
1500 1.21.2.5 he (u_int64_t)hz / 1000;
1501 1.21.2.5 he if (timeout == 0)
1502 1.21.2.5 he timeout = 1;
1503 1.21.2.5 he callout_reset( &siop_cmd->xs->xs_callout,
1504 1.21.2.5 he timeout, siop_timeout, siop_cmd);
1505 1.7 bouyer }
1506 1.1 bouyer }
1507 1.21.2.5 he /*
1508 1.21.2.5 he * Change JUMP cmd so that this slot will be handled
1509 1.21.2.5 he */
1510 1.21.2.5 he siop_script_write(sc, (Ent_script_sched_slot0 / 4) + slot * 2,
1511 1.21.2.5 he 0x80080000);
1512 1.21.2.5 he sc->sc_currschedslot = slot;
1513 1.21.2.5 he slot++;
1514 1.1 bouyer }
1515 1.21.2.5 he if (doingready == 0) {
1516 1.21.2.5 he /* now process ready list */
1517 1.21.2.5 he doingready = 1;
1518 1.21.2.5 he siop_cmd = TAILQ_FIRST(&sc->ready_list);
1519 1.21.2.5 he goto again;
1520 1.21.2.5 he }
1521 1.21.2.5 he
1522 1.7 bouyer end:
1523 1.2 bouyer /* if nothing changed no need to flush cache and wakeup script */
1524 1.2 bouyer if (newcmd == 0)
1525 1.1 bouyer return;
1526 1.2 bouyer /* make sure SCRIPT processor will read valid data */
1527 1.21.2.5 he siop_script_sync(sc,BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1528 1.2 bouyer /* Signal script it has some work to do */
1529 1.2 bouyer bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_ISTAT, ISTAT_SIGP);
1530 1.2 bouyer /* and wait for IRQ */
1531 1.2 bouyer return;
1532 1.1 bouyer }
1533 1.1 bouyer
1534 1.1 bouyer void
1535 1.1 bouyer siop_timeout(v)
1536 1.1 bouyer void *v;
1537 1.1 bouyer {
1538 1.1 bouyer struct siop_cmd *siop_cmd = v;
1539 1.21.2.5 he struct siop_softc *sc = siop_cmd->siop_sc;
1540 1.1 bouyer int s;
1541 1.1 bouyer
1542 1.1 bouyer scsi_print_addr(siop_cmd->xs->sc_link);
1543 1.1 bouyer printf("command timeout\n");
1544 1.1 bouyer
1545 1.1 bouyer s = splbio();
1546 1.1 bouyer /* reset the scsi bus */
1547 1.21.2.2 bouyer siop_resetbus(sc);
1548 1.1 bouyer
1549 1.12 soren /* deactivate callout */
1550 1.1 bouyer callout_stop(&siop_cmd->xs->xs_callout);
1551 1.21.2.5 he /* mark command as being timed out; siop_intr will handle it */
1552 1.1 bouyer /*
1553 1.1 bouyer * mark command has being timed out and just return;
1554 1.1 bouyer * the bus reset will generate an interrupt,
1555 1.1 bouyer * it will be handled in siop_intr()
1556 1.1 bouyer */
1557 1.1 bouyer siop_cmd->flags |= CMDFL_TIMEOUT;
1558 1.1 bouyer splx(s);
1559 1.1 bouyer return;
1560 1.1 bouyer
1561 1.1 bouyer }
1562 1.2 bouyer
1563 1.2 bouyer void
1564 1.2 bouyer siop_dump_script(sc)
1565 1.2 bouyer struct siop_softc *sc;
1566 1.2 bouyer {
1567 1.2 bouyer int i;
1568 1.16 bouyer for (i = 0; i < NBPG / 4; i += 2) {
1569 1.4 bouyer printf("0x%04x: 0x%08x 0x%08x", i * 4,
1570 1.4 bouyer le32toh(sc->sc_script[i]), le32toh(sc->sc_script[i+1]));
1571 1.4 bouyer if ((le32toh(sc->sc_script[i]) & 0xe0000000) == 0xc0000000) {
1572 1.2 bouyer i++;
1573 1.4 bouyer printf(" 0x%08x", le32toh(sc->sc_script[i+1]));
1574 1.2 bouyer }
1575 1.2 bouyer printf("\n");
1576 1.2 bouyer }
1577 1.16 bouyer }
1578 1.16 bouyer
1579 1.16 bouyer int
1580 1.16 bouyer siop_morecbd(sc)
1581 1.16 bouyer struct siop_softc *sc;
1582 1.16 bouyer {
1583 1.21.2.5 he int error, i, j;
1584 1.16 bouyer bus_dma_segment_t seg;
1585 1.16 bouyer int rseg;
1586 1.16 bouyer struct siop_cbd *newcbd;
1587 1.21.2.5 he bus_addr_t dsa;
1588 1.21.2.5 he u_int32_t *scr;
1589 1.16 bouyer
1590 1.16 bouyer /* allocate a new list head */
1591 1.16 bouyer newcbd = malloc(sizeof(struct siop_cbd), M_DEVBUF, M_NOWAIT);
1592 1.16 bouyer if (newcbd == NULL) {
1593 1.16 bouyer printf("%s: can't allocate memory for command descriptors "
1594 1.16 bouyer "head\n", sc->sc_dev.dv_xname);
1595 1.16 bouyer return ENOMEM;
1596 1.16 bouyer }
1597 1.21.2.5 he memset(newcbd, 0, sizeof(struct siop_cbd));
1598 1.16 bouyer
1599 1.16 bouyer /* allocate cmd list */
1600 1.16 bouyer newcbd->cmds =
1601 1.16 bouyer malloc(sizeof(struct siop_cmd) * SIOP_NCMDPB, M_DEVBUF, M_NOWAIT);
1602 1.16 bouyer if (newcbd->cmds == NULL) {
1603 1.16 bouyer printf("%s: can't allocate memory for command descriptors\n",
1604 1.16 bouyer sc->sc_dev.dv_xname);
1605 1.16 bouyer error = ENOMEM;
1606 1.16 bouyer goto bad3;
1607 1.16 bouyer }
1608 1.21.2.5 he memset(newcbd->cmds, 0, sizeof(struct siop_cmd) * SIOP_NCMDPB);
1609 1.16 bouyer error = bus_dmamem_alloc(sc->sc_dmat, NBPG, NBPG, 0, &seg, 1, &rseg,
1610 1.16 bouyer BUS_DMA_NOWAIT);
1611 1.16 bouyer if (error) {
1612 1.16 bouyer printf("%s: unable to allocate cbd DMA memory, error = %d\n",
1613 1.16 bouyer sc->sc_dev.dv_xname, error);
1614 1.16 bouyer goto bad2;
1615 1.16 bouyer }
1616 1.16 bouyer error = bus_dmamem_map(sc->sc_dmat, &seg, rseg, NBPG,
1617 1.16 bouyer (caddr_t *)&newcbd->xfers, BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
1618 1.16 bouyer if (error) {
1619 1.16 bouyer printf("%s: unable to map cbd DMA memory, error = %d\n",
1620 1.16 bouyer sc->sc_dev.dv_xname, error);
1621 1.16 bouyer goto bad2;
1622 1.16 bouyer }
1623 1.16 bouyer error = bus_dmamap_create(sc->sc_dmat, NBPG, 1, NBPG, 0,
1624 1.16 bouyer BUS_DMA_NOWAIT, &newcbd->xferdma);
1625 1.16 bouyer if (error) {
1626 1.16 bouyer printf("%s: unable to create cbd DMA map, error = %d\n",
1627 1.16 bouyer sc->sc_dev.dv_xname, error);
1628 1.16 bouyer goto bad1;
1629 1.16 bouyer }
1630 1.16 bouyer error = bus_dmamap_load(sc->sc_dmat, newcbd->xferdma, newcbd->xfers,
1631 1.16 bouyer NBPG, NULL, BUS_DMA_NOWAIT);
1632 1.16 bouyer if (error) {
1633 1.17 bouyer printf("%s: unable to load cbd DMA map, error = %d\n",
1634 1.16 bouyer sc->sc_dev.dv_xname, error);
1635 1.16 bouyer goto bad0;
1636 1.16 bouyer }
1637 1.21.2.5 he #ifdef DEBUG
1638 1.21.2.5 he printf("%s: alloc newcdb at PHY addr 0x%lx\n", sc->sc_dev.dv_xname,
1639 1.21.2.5 he (unsigned long)newcbd->xferdma->dm_segs[0].ds_addr);
1640 1.21.2.5 he #endif
1641 1.16 bouyer
1642 1.16 bouyer for (i = 0; i < SIOP_NCMDPB; i++) {
1643 1.16 bouyer error = bus_dmamap_create(sc->sc_dmat, MAXPHYS, SIOP_NSG,
1644 1.16 bouyer MAXPHYS, 0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
1645 1.16 bouyer &newcbd->cmds[i].dmamap_data);
1646 1.16 bouyer if (error) {
1647 1.16 bouyer printf("%s: unable to create data DMA map for cbd: "
1648 1.16 bouyer "error %d\n",
1649 1.16 bouyer sc->sc_dev.dv_xname, error);
1650 1.16 bouyer goto bad0;
1651 1.16 bouyer }
1652 1.16 bouyer error = bus_dmamap_create(sc->sc_dmat,
1653 1.16 bouyer sizeof(struct scsipi_generic), 1,
1654 1.16 bouyer sizeof(struct scsipi_generic), 0,
1655 1.16 bouyer BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
1656 1.16 bouyer &newcbd->cmds[i].dmamap_cmd);
1657 1.16 bouyer if (error) {
1658 1.16 bouyer printf("%s: unable to create cmd DMA map for cbd %d\n",
1659 1.16 bouyer sc->sc_dev.dv_xname, error);
1660 1.16 bouyer goto bad0;
1661 1.16 bouyer }
1662 1.21.2.5 he newcbd->cmds[i].siop_sc = sc;
1663 1.16 bouyer newcbd->cmds[i].siop_cbdp = newcbd;
1664 1.21.2.5 he newcbd->cmds[i].siop_xfer = &newcbd->xfers[i];
1665 1.21.2.5 he memset(newcbd->cmds[i].siop_xfer, 0,
1666 1.21.2.5 he sizeof(struct siop_xfer));
1667 1.16 bouyer newcbd->cmds[i].dsa = newcbd->xferdma->dm_segs[0].ds_addr +
1668 1.16 bouyer i * sizeof(struct siop_xfer);
1669 1.21.2.5 he dsa = newcbd->cmds[i].dsa;
1670 1.16 bouyer newcbd->cmds[i].status = CMDST_FREE;
1671 1.21.2.5 he newcbd->cmds[i].siop_tables.t_msgout.count= htole32(1);
1672 1.21.2.5 he newcbd->cmds[i].siop_tables.t_msgout.addr = htole32(dsa);
1673 1.21.2.5 he newcbd->cmds[i].siop_tables.t_msgin.count= htole32(1);
1674 1.21.2.5 he newcbd->cmds[i].siop_tables.t_msgin.addr = htole32(dsa + 8);
1675 1.21.2.5 he newcbd->cmds[i].siop_tables.t_extmsgin.count= htole32(2);
1676 1.21.2.5 he newcbd->cmds[i].siop_tables.t_extmsgin.addr = htole32(dsa + 9);
1677 1.21.2.5 he newcbd->cmds[i].siop_tables.t_extmsgdata.addr =
1678 1.21.2.5 he htole32(dsa + 11);
1679 1.21.2.5 he newcbd->cmds[i].siop_tables.t_status.count= htole32(1);
1680 1.21.2.5 he newcbd->cmds[i].siop_tables.t_status.addr = htole32(dsa + 16);
1681 1.21.2.5 he
1682 1.21.2.5 he /* The select/reselect script */
1683 1.21.2.5 he scr = &newcbd->cmds[i].siop_xfer->resel[0];
1684 1.21.2.5 he for (j = 0; j < sizeof(load_dsa) / sizeof(load_dsa[0]); j++)
1685 1.21.2.5 he scr[j] = htole32(load_dsa[j]);
1686 1.21.2.5 he /*
1687 1.21.2.5 he * 0x78000000 is a 'move data8 to reg'. data8 is the second
1688 1.21.2.5 he * octet, reg offset is the third.
1689 1.21.2.5 he */
1690 1.21.2.5 he scr[Ent_rdsa0 / 4] =
1691 1.21.2.5 he htole32(0x78100000 | ((dsa & 0x000000ff) << 8));
1692 1.21.2.5 he scr[Ent_rdsa1 / 4] =
1693 1.21.2.5 he htole32(0x78110000 | ( dsa & 0x0000ff00 ));
1694 1.21.2.5 he scr[Ent_rdsa2 / 4] =
1695 1.21.2.5 he htole32(0x78120000 | ((dsa & 0x00ff0000) >> 8));
1696 1.21.2.5 he scr[Ent_rdsa3 / 4] =
1697 1.21.2.5 he htole32(0x78130000 | ((dsa & 0xff000000) >> 16));
1698 1.21.2.5 he scr[E_ldsa_abs_reselected_Used[0]] =
1699 1.21.2.5 he htole32(sc->sc_scriptaddr + Ent_reselected);
1700 1.21.2.5 he scr[E_ldsa_abs_reselect_Used[0]] =
1701 1.21.2.5 he htole32(sc->sc_scriptaddr + Ent_reselect);
1702 1.21.2.5 he scr[E_ldsa_abs_selected_Used[0]] =
1703 1.21.2.5 he htole32(sc->sc_scriptaddr + Ent_selected);
1704 1.21.2.5 he scr[E_ldsa_abs_data_Used[0]] =
1705 1.21.2.5 he htole32(dsa + sizeof(struct siop_xfer_common) +
1706 1.21.2.5 he Ent_ldsa_data);
1707 1.21.2.5 he /* JUMP foo, IF FALSE - used by MOVE MEMORY to clear the slot */
1708 1.21.2.5 he scr[Ent_ldsa_data / 4] = htole32(0x80000000);
1709 1.16 bouyer TAILQ_INSERT_TAIL(&sc->free_list, &newcbd->cmds[i], next);
1710 1.21.2.5 he #ifdef SIOP_DEBUG
1711 1.21.2.5 he printf("tables[%d]: in=0x%x out=0x%x status=0x%x\n", i,
1712 1.21.2.5 he le32toh(newcbd->cmds[i].siop_tables.t_msgin.addr),
1713 1.21.2.5 he le32toh(newcbd->cmds[i].siop_tables.t_msgout.addr),
1714 1.21.2.5 he le32toh(newcbd->cmds[i].siop_tables.t_status.addr));
1715 1.16 bouyer #endif
1716 1.16 bouyer }
1717 1.16 bouyer TAILQ_INSERT_TAIL(&sc->cmds, newcbd, next);
1718 1.16 bouyer return 0;
1719 1.16 bouyer bad0:
1720 1.16 bouyer bus_dmamap_destroy(sc->sc_dmat, newcbd->xferdma);
1721 1.16 bouyer bad1:
1722 1.16 bouyer bus_dmamem_free(sc->sc_dmat, &seg, rseg);
1723 1.16 bouyer bad2:
1724 1.16 bouyer free(newcbd->cmds, M_DEVBUF);
1725 1.16 bouyer bad3:
1726 1.16 bouyer free(newcbd, M_DEVBUF);
1727 1.16 bouyer return error;
1728 1.2 bouyer }
1729 1.2 bouyer
1730 1.21.2.5 he struct siop_lunsw *
1731 1.21.2.5 he siop_get_lunsw(sc)
1732 1.21.2.5 he struct siop_softc *sc;
1733 1.21.2.5 he {
1734 1.21.2.5 he struct siop_lunsw *lunsw;
1735 1.21.2.5 he int i;
1736 1.21.2.5 he
1737 1.21.2.5 he if (sc->script_free_lo + (sizeof(lun_switch) / sizeof(lun_switch[0])) >=
1738 1.21.2.5 he sc->script_free_hi)
1739 1.21.2.5 he return NULL;
1740 1.21.2.5 he lunsw = TAILQ_FIRST(&sc->lunsw_list);
1741 1.21.2.5 he if (lunsw != NULL) {
1742 1.21.2.5 he #ifdef SIOP_DEBUG
1743 1.21.2.5 he printf("siop_get_lunsw got lunsw at offset %d\n",
1744 1.21.2.5 he lunsw->lunsw_off);
1745 1.21.2.5 he #endif
1746 1.21.2.5 he TAILQ_REMOVE(&sc->lunsw_list, lunsw, next);
1747 1.21.2.5 he return lunsw;
1748 1.21.2.5 he }
1749 1.21.2.5 he lunsw = malloc(sizeof(struct siop_lunsw), M_DEVBUF, M_NOWAIT);
1750 1.21.2.5 he if (lunsw == NULL)
1751 1.21.2.5 he return NULL;
1752 1.21.2.5 he memset(lunsw, 0, sizeof(struct siop_lunsw));
1753 1.21.2.5 he #ifdef SIOP_DEBUG
1754 1.21.2.5 he printf("allocating lunsw at offset %d\n", sc->script_free_lo);
1755 1.21.2.5 he #endif
1756 1.21.2.5 he if (sc->features & SF_CHIP_RAM) {
1757 1.21.2.5 he bus_space_write_region_4(sc->sc_ramt, sc->sc_ramh,
1758 1.21.2.5 he sc->script_free_lo * 4, lun_switch,
1759 1.21.2.5 he sizeof(lun_switch) / sizeof(lun_switch[0]));
1760 1.21.2.5 he bus_space_write_4(sc->sc_ramt, sc->sc_ramh,
1761 1.21.2.5 he (sc->script_free_lo + E_abs_lunsw_return_Used[0]) * 4,
1762 1.21.2.5 he sc->sc_scriptaddr + Ent_lunsw_return);
1763 1.21.2.5 he } else {
1764 1.21.2.5 he for (i = 0; i < sizeof(lun_switch) / sizeof(lun_switch[0]);
1765 1.21.2.5 he i++)
1766 1.21.2.5 he sc->sc_script[sc->script_free_lo + i] =
1767 1.21.2.5 he htole32(lun_switch[i]);
1768 1.21.2.5 he sc->sc_script[sc->script_free_lo + E_abs_lunsw_return_Used[0]] =
1769 1.21.2.5 he htole32(sc->sc_scriptaddr + Ent_lunsw_return);
1770 1.21.2.5 he }
1771 1.21.2.5 he lunsw->lunsw_off = sc->script_free_lo;
1772 1.21.2.5 he lunsw->lunsw_size = sizeof(lun_switch) / sizeof(lun_switch[0]);
1773 1.21.2.5 he sc->script_free_lo += lunsw->lunsw_size;
1774 1.21.2.5 he if (sc->script_free_lo > 1024)
1775 1.21.2.5 he printf("%s: script_free_lo (%d) > 1024\n", sc->sc_dev.dv_xname,
1776 1.21.2.5 he sc->script_free_lo);
1777 1.21.2.5 he siop_script_sync(sc, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1778 1.21.2.5 he return lunsw;
1779 1.21.2.5 he }
1780 1.21.2.5 he
1781 1.21.2.5 he void
1782 1.21.2.5 he siop_add_reselsw(sc, target)
1783 1.21.2.5 he struct siop_softc *sc;
1784 1.21.2.5 he int target;
1785 1.21.2.5 he {
1786 1.21.2.5 he int i;
1787 1.21.2.5 he struct siop_lun *siop_lun;
1788 1.21.2.5 he /*
1789 1.21.2.5 he * add an entry to resel switch
1790 1.21.2.5 he */
1791 1.21.2.5 he siop_script_sync(sc, BUS_DMASYNC_POSTWRITE);
1792 1.21.2.5 he for (i = 0; i < 15; i++) {
1793 1.21.2.5 he sc->targets[target]->reseloff = Ent_resel_targ0 / 4 + i * 2;
1794 1.21.2.5 he if ((siop_script_read(sc, sc->targets[target]->reseloff) & 0xff)
1795 1.21.2.5 he == 0xff) { /* it's free */
1796 1.21.2.5 he #ifdef SIOP_DEBUG
1797 1.21.2.5 he printf("siop: target %d slot %d offset %d\n",
1798 1.21.2.5 he target, i, sc->targets[target]->reseloff);
1799 1.21.2.5 he #endif
1800 1.21.2.5 he /* JUMP abs_foo, IF target | 0x80; */
1801 1.21.2.5 he siop_script_write(sc, sc->targets[target]->reseloff,
1802 1.21.2.5 he 0x800c0080 | target);
1803 1.21.2.5 he siop_script_write(sc, sc->targets[target]->reseloff + 1,
1804 1.21.2.5 he sc->sc_scriptaddr +
1805 1.21.2.5 he sc->targets[target]->lunsw->lunsw_off * 4 +
1806 1.21.2.5 he Ent_lun_switch_entry);
1807 1.21.2.5 he break;
1808 1.21.2.5 he }
1809 1.21.2.5 he }
1810 1.21.2.5 he if (i == 15) /* no free slot, shouldn't happen */
1811 1.21.2.5 he panic("siop: resel switch full");
1812 1.21.2.5 he
1813 1.21.2.5 he sc->sc_ntargets++;
1814 1.21.2.5 he for (i = 0; i < 8; i++) {
1815 1.21.2.5 he siop_lun = sc->targets[target]->siop_lun[i];
1816 1.21.2.5 he if (siop_lun == NULL)
1817 1.21.2.5 he continue;
1818 1.21.2.5 he if (siop_lun->reseloff > 0) {
1819 1.21.2.5 he siop_lun->reseloff = 0;
1820 1.21.2.5 he siop_add_dev(sc, target, i);
1821 1.21.2.5 he }
1822 1.21.2.5 he }
1823 1.21.2.5 he siop_update_scntl3(sc, sc->targets[target]);
1824 1.21.2.5 he siop_script_sync(sc, BUS_DMASYNC_PREWRITE);
1825 1.21.2.5 he }
1826 1.21.2.5 he
1827 1.21.2.5 he void
1828 1.21.2.5 he siop_update_scntl3(sc, siop_target)
1829 1.21.2.5 he struct siop_softc *sc;
1830 1.21.2.5 he struct siop_target *siop_target;
1831 1.21.2.5 he {
1832 1.21.2.5 he /* MOVE target->id >> 24 TO SCNTL3 */
1833 1.21.2.5 he siop_script_write(sc,
1834 1.21.2.5 he siop_target->lunsw->lunsw_off + (Ent_restore_scntl3 / 4),
1835 1.21.2.5 he 0x78030000 | ((siop_target->id >> 16) & 0x0000ff00));
1836 1.21.2.5 he /* MOVE target->id >> 8 TO SXFER */
1837 1.21.2.5 he siop_script_write(sc,
1838 1.21.2.5 he siop_target->lunsw->lunsw_off + (Ent_restore_scntl3 / 4) + 2,
1839 1.21.2.5 he 0x78050000 | (siop_target->id & 0x0000ff00));
1840 1.21.2.5 he siop_script_sync(sc, BUS_DMASYNC_PREWRITE);
1841 1.21.2.5 he }
1842 1.21.2.5 he
1843 1.21.2.5 he void
1844 1.21.2.5 he siop_add_dev(sc, target, lun)
1845 1.21.2.5 he struct siop_softc *sc;
1846 1.21.2.5 he int target;
1847 1.21.2.5 he int lun;
1848 1.21.2.5 he {
1849 1.21.2.5 he struct siop_lunsw *lunsw;
1850 1.21.2.5 he struct siop_lun *siop_lun = sc->targets[target]->siop_lun[lun];
1851 1.21.2.5 he int i, ntargets;
1852 1.21.2.5 he
1853 1.21.2.5 he if (siop_lun->reseloff > 0)
1854 1.21.2.5 he return;
1855 1.21.2.5 he lunsw = sc->targets[target]->lunsw;
1856 1.21.2.5 he if ((lunsw->lunsw_off + lunsw->lunsw_size) < sc->script_free_lo) {
1857 1.21.2.5 he /*
1858 1.21.2.5 he * can't extend this slot. Probably not worth trying to deal
1859 1.21.2.5 he * with this case
1860 1.21.2.5 he */
1861 1.21.2.5 he #ifdef DEBUG
1862 1.21.2.5 he printf("%s:%d:%d: can't allocate a lun sw slot\n",
1863 1.21.2.5 he sc->sc_dev.dv_xname, target, lun);
1864 1.21.2.5 he #endif
1865 1.21.2.5 he return;
1866 1.21.2.5 he }
1867 1.21.2.5 he /* count how many free targets we still have to probe */
1868 1.21.2.5 he ntargets = sc->sc_link.scsipi_scsi.max_target - 1 - sc->sc_ntargets;
1869 1.21.2.5 he
1870 1.21.2.5 he /*
1871 1.21.2.5 he * we need 8 bytes for the lun sw additionnal entry, and
1872 1.21.2.5 he * eventually sizeof(tag_switch) for the tag switch entry.
1873 1.21.2.5 he * Keep enouth free space for the free targets that could be
1874 1.21.2.5 he * probed later.
1875 1.21.2.5 he */
1876 1.21.2.5 he if (sc->script_free_lo + 2 +
1877 1.21.2.5 he (ntargets * sizeof(lun_switch) / sizeof(lun_switch[0])) >=
1878 1.21.2.5 he ((sc->targets[target]->flags & TARF_TAG) ?
1879 1.21.2.5 he sc->script_free_hi - (sizeof(tag_switch) / sizeof(tag_switch[0])) :
1880 1.21.2.5 he sc->script_free_hi)) {
1881 1.21.2.5 he /*
1882 1.21.2.5 he * not enouth space, probably not worth dealing with it.
1883 1.21.2.5 he * We can hold 13 tagged-queuing capable devices in the 4k RAM.
1884 1.21.2.5 he */
1885 1.21.2.5 he #ifdef DEBUG
1886 1.21.2.5 he printf("%s:%d:%d: not enouth memory for a lun sw slot\n",
1887 1.21.2.5 he sc->sc_dev.dv_xname, target, lun);
1888 1.21.2.5 he #endif
1889 1.21.2.5 he return;
1890 1.21.2.5 he }
1891 1.21.2.5 he #ifdef SIOP_DEBUG
1892 1.21.2.5 he printf("%s:%d:%d: allocate lun sw entry\n",
1893 1.21.2.5 he sc->sc_dev.dv_xname, target, lun);
1894 1.21.2.5 he #endif
1895 1.21.2.5 he /* INT int_resellun */
1896 1.21.2.5 he siop_script_write(sc, sc->script_free_lo, 0x98080000);
1897 1.21.2.5 he siop_script_write(sc, sc->script_free_lo + 1, A_int_resellun);
1898 1.21.2.5 he /* Now the slot entry: JUMP abs_foo, IF lun */
1899 1.21.2.5 he siop_script_write(sc, sc->script_free_lo - 2,
1900 1.21.2.5 he 0x800c0000 | lun);
1901 1.21.2.5 he siop_script_write(sc, sc->script_free_lo - 1, 0);
1902 1.21.2.5 he siop_lun->reseloff = sc->script_free_lo - 2;
1903 1.21.2.5 he lunsw->lunsw_size += 2;
1904 1.21.2.5 he sc->script_free_lo += 2;
1905 1.21.2.5 he if (sc->targets[target]->flags & TARF_TAG) {
1906 1.21.2.5 he /* we need a tag switch */
1907 1.21.2.5 he sc->script_free_hi -=
1908 1.21.2.5 he sizeof(tag_switch) / sizeof(tag_switch[0]);
1909 1.21.2.5 he if (sc->features & SF_CHIP_RAM) {
1910 1.21.2.5 he bus_space_write_region_4(sc->sc_ramt, sc->sc_ramh,
1911 1.21.2.5 he sc->script_free_hi * 4, tag_switch,
1912 1.21.2.5 he sizeof(tag_switch) / sizeof(tag_switch[0]));
1913 1.21.2.5 he } else {
1914 1.21.2.5 he for(i = 0;
1915 1.21.2.5 he i < sizeof(tag_switch) / sizeof(tag_switch[0]);
1916 1.21.2.5 he i++) {
1917 1.21.2.5 he sc->sc_script[sc->script_free_hi + i] =
1918 1.21.2.5 he htole32(tag_switch[i]);
1919 1.21.2.5 he }
1920 1.21.2.5 he }
1921 1.21.2.5 he siop_script_write(sc,
1922 1.21.2.5 he siop_lun->reseloff + 1,
1923 1.21.2.5 he sc->sc_scriptaddr + sc->script_free_hi * 4 +
1924 1.21.2.5 he Ent_tag_switch_entry);
1925 1.21.2.5 he
1926 1.21.2.5 he for (i = 0; i < SIOP_NTAG; i++) {
1927 1.21.2.5 he siop_lun->siop_tag[i].reseloff =
1928 1.21.2.5 he sc->script_free_hi + (Ent_resel_tag0 / 4) + i * 2;
1929 1.21.2.5 he }
1930 1.21.2.5 he } else {
1931 1.21.2.5 he /* non-tag case; just work with the lun switch */
1932 1.21.2.5 he siop_lun->siop_tag[0].reseloff =
1933 1.21.2.5 he sc->targets[target]->siop_lun[lun]->reseloff;
1934 1.21.2.5 he }
1935 1.21.2.5 he siop_script_sync(sc, BUS_DMASYNC_PREWRITE);
1936 1.21.2.5 he }
1937 1.21.2.5 he
1938 1.21.2.5 he void
1939 1.21.2.5 he siop_del_dev(sc, target, lun)
1940 1.21.2.5 he struct siop_softc *sc;
1941 1.21.2.5 he int target;
1942 1.21.2.5 he int lun;
1943 1.21.2.5 he {
1944 1.21.2.5 he int i;
1945 1.21.2.5 he #ifdef SIOP_DEBUG
1946 1.21.2.5 he printf("%s:%d:%d: free lun sw entry\n",
1947 1.21.2.5 he sc->sc_dev.dv_xname, target, lun);
1948 1.21.2.5 he #endif
1949 1.21.2.5 he if (sc->targets[target] == NULL)
1950 1.21.2.5 he return;
1951 1.21.2.5 he free(sc->targets[target]->siop_lun[lun], M_DEVBUF);
1952 1.21.2.5 he sc->targets[target]->siop_lun[lun] = NULL;
1953 1.21.2.5 he /* XXX compact sw entry too ? */
1954 1.21.2.5 he /* check if we can free the whole target */
1955 1.21.2.5 he for (i = 0; i < 8; i++) {
1956 1.21.2.5 he if (sc->targets[target]->siop_lun[i] != NULL)
1957 1.21.2.5 he return;
1958 1.21.2.5 he }
1959 1.21.2.5 he #ifdef SIOP_DEBUG
1960 1.21.2.5 he printf("%s: free siop_target for target %d lun %d lunsw offset %d\n",
1961 1.21.2.5 he sc->sc_dev.dv_xname, target, lun,
1962 1.21.2.5 he sc->targets[target]->lunsw->lunsw_off);
1963 1.21.2.5 he #endif
1964 1.21.2.5 he /*
1965 1.21.2.5 he * nothing here, free the target struct and resel
1966 1.21.2.5 he * switch entry
1967 1.21.2.5 he */
1968 1.21.2.5 he siop_script_write(sc, sc->targets[target]->reseloff, 0x800c00ff);
1969 1.21.2.5 he siop_script_sync(sc, BUS_DMASYNC_PREWRITE);
1970 1.21.2.5 he TAILQ_INSERT_TAIL(&sc->lunsw_list, sc->targets[target]->lunsw, next);
1971 1.21.2.5 he free(sc->targets[target], M_DEVBUF);
1972 1.21.2.5 he sc->targets[target] = NULL;
1973 1.21.2.5 he sc->sc_ntargets--;
1974 1.21.2.5 he }
1975 1.21.2.5 he
1976 1.2 bouyer #ifdef SIOP_STATS
1977 1.2 bouyer void
1978 1.2 bouyer siop_printstats()
1979 1.2 bouyer {
1980 1.2 bouyer printf("siop_stat_intr %d\n", siop_stat_intr);
1981 1.2 bouyer printf("siop_stat_intr_shortxfer %d\n", siop_stat_intr_shortxfer);
1982 1.2 bouyer printf("siop_stat_intr_xferdisc %d\n", siop_stat_intr_xferdisc);
1983 1.2 bouyer printf("siop_stat_intr_sdp %d\n", siop_stat_intr_sdp);
1984 1.2 bouyer printf("siop_stat_intr_done %d\n", siop_stat_intr_done);
1985 1.21.2.5 he printf("siop_stat_intr_lunresel %d\n", siop_stat_intr_lunresel);
1986 1.21.2.5 he printf("siop_stat_intr_qfull %d\n", siop_stat_intr_qfull);
1987 1.2 bouyer }
1988 1.2 bouyer #endif
1989