1/*-
2 * Copyright (c) 2004 Scott Long
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 */
27
| 1/*-
2 * Copyright (c) 2004 Scott Long
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 */
27
|
28/* $NetBSD: ncr53c9x.c,v 1.110 2003/11/02 11:07:45 wiz Exp $ */
| 28/* $NetBSD: ncr53c9x.c,v 1.114 2005/02/27 00:27:02 perry Exp $ */
|
29
30/*-
31 * Copyright (c) 1998, 2002 The NetBSD Foundation, Inc.
32 * All rights reserved.
33 *
34 * This code is derived from software contributed to The NetBSD Foundation
35 * by Charles M. Hannum.
36 *
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
39 * are met:
40 * 1. Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 * 3. All advertising materials mentioning features or use of this software
46 * must display the following acknowledgement:
47 * This product includes software developed by the NetBSD
48 * Foundation, Inc. and its contributors.
49 * 4. Neither the name of The NetBSD Foundation nor the names of its
50 * contributors may be used to endorse or promote products derived
51 * from this software without specific prior written permission.
52 *
53 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
54 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
55 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
56 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
57 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
58 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
59 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
60 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
61 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
62 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
63 * POSSIBILITY OF SUCH DAMAGE.
64 */
65
66/*-
67 * Copyright (c) 1994 Peter Galbavy
68 * Copyright (c) 1995 Paul Kranenburg
69 * All rights reserved.
70 *
71 * Redistribution and use in source and binary forms, with or without
72 * modification, are permitted provided that the following conditions
73 * are met:
74 * 1. Redistributions of source code must retain the above copyright
75 * notice, this list of conditions and the following disclaimer.
76 * 2. Redistributions in binary form must reproduce the above copyright
77 * notice, this list of conditions and the following disclaimer in the
78 * documentation and/or other materials provided with the distribution.
79 * 3. All advertising materials mentioning features or use of this software
80 * must display the following acknowledgement:
81 * This product includes software developed by Peter Galbavy
82 * 4. The name of the author may not be used to endorse or promote products
83 * derived from this software without specific prior written permission.
84 *
85 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
86 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
87 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
88 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
89 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
90 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
91 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
92 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
93 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
94 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
95 * POSSIBILITY OF SUCH DAMAGE.
96 */
97
98/*
99 * Based on aic6360 by Jarle Greipsland
100 *
101 * Acknowledgements: Many of the algorithms used in this driver are
102 * inspired by the work of Julian Elischer (julian@FreeBSD.org) and
103 * Charles Hannum (mycroft@duality.gnu.ai.mit.edu). Thanks a million!
104 */
105
106#include <sys/cdefs.h>
| 29
30/*-
31 * Copyright (c) 1998, 2002 The NetBSD Foundation, Inc.
32 * All rights reserved.
33 *
34 * This code is derived from software contributed to The NetBSD Foundation
35 * by Charles M. Hannum.
36 *
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
39 * are met:
40 * 1. Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 * 3. All advertising materials mentioning features or use of this software
46 * must display the following acknowledgement:
47 * This product includes software developed by the NetBSD
48 * Foundation, Inc. and its contributors.
49 * 4. Neither the name of The NetBSD Foundation nor the names of its
50 * contributors may be used to endorse or promote products derived
51 * from this software without specific prior written permission.
52 *
53 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
54 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
55 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
56 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
57 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
58 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
59 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
60 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
61 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
62 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
63 * POSSIBILITY OF SUCH DAMAGE.
64 */
65
66/*-
67 * Copyright (c) 1994 Peter Galbavy
68 * Copyright (c) 1995 Paul Kranenburg
69 * All rights reserved.
70 *
71 * Redistribution and use in source and binary forms, with or without
72 * modification, are permitted provided that the following conditions
73 * are met:
74 * 1. Redistributions of source code must retain the above copyright
75 * notice, this list of conditions and the following disclaimer.
76 * 2. Redistributions in binary form must reproduce the above copyright
77 * notice, this list of conditions and the following disclaimer in the
78 * documentation and/or other materials provided with the distribution.
79 * 3. All advertising materials mentioning features or use of this software
80 * must display the following acknowledgement:
81 * This product includes software developed by Peter Galbavy
82 * 4. The name of the author may not be used to endorse or promote products
83 * derived from this software without specific prior written permission.
84 *
85 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
86 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
87 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
88 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
89 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
90 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
91 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
92 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
93 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
94 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
95 * POSSIBILITY OF SUCH DAMAGE.
96 */
97
98/*
99 * Based on aic6360 by Jarle Greipsland
100 *
101 * Acknowledgements: Many of the algorithms used in this driver are
102 * inspired by the work of Julian Elischer (julian@FreeBSD.org) and
103 * Charles Hannum (mycroft@duality.gnu.ai.mit.edu). Thanks a million!
104 */
105
106#include <sys/cdefs.h>
|
107__FBSDID("$FreeBSD: head/sys/dev/esp/ncr53c9x.c 145535 2005-04-25 22:11:43Z scottl $");
| 107__FBSDID("$FreeBSD: head/sys/dev/esp/ncr53c9x.c 146392 2005-05-19 14:51:10Z marius $");
|
108
109#include <sys/param.h>
110#include <sys/systm.h>
111#include <sys/bus.h>
112#include <sys/kernel.h>
113#include <sys/malloc.h>
114#include <sys/resource.h>
115#include <sys/lock.h>
116#include <sys/mutex.h>
117#include <sys/queue.h>
118#include <sys/time.h>
119#include <sys/callout.h>
120
121#include <cam/cam.h>
122#include <cam/cam_ccb.h>
123#include <cam/cam_debug.h>
124#include <cam/cam_sim.h>
125#include <cam/cam_xpt_sim.h>
126#include <cam/scsi/scsi_all.h>
127#include <cam/scsi/scsi_message.h>
128
129#include <dev/esp/ncr53c9xreg.h>
130#include <dev/esp/ncr53c9xvar.h>
131
132int ncr53c9x_debug = NCR_SHOWMISC /*|NCR_SHOWPHASE|NCR_SHOWTRAC|NCR_SHOWCMDS*/;
133#ifdef DEBUG
134int ncr53c9x_notag = 0;
135#endif
136
137static void ncr53c9x_select(struct ncr53c9x_softc *, struct ncr53c9x_ecb *);
138static int ncr53c9x_reselect(struct ncr53c9x_softc *, int, int, int);
139static void ncr53c9x_scsi_reset(struct ncr53c9x_softc *);
140static void ncr53c9x_poll(struct cam_sim *);
141static void ncr53c9x_sched(struct ncr53c9x_softc *);
142static void ncr53c9x_done(struct ncr53c9x_softc *, struct ncr53c9x_ecb *);
143static void ncr53c9x_msgin(struct ncr53c9x_softc *);
144static void ncr53c9x_msgout(struct ncr53c9x_softc *);
145static void ncr53c9x_timeout(void *arg);
146static void ncr53c9x_watch(void *arg);
147static void ncr53c9x_abort(struct ncr53c9x_softc *, struct ncr53c9x_ecb *);
148static void ncr53c9x_dequeue(struct ncr53c9x_softc *,
149 struct ncr53c9x_ecb *);
150static void ncr53c9x_sense(struct ncr53c9x_softc *, struct ncr53c9x_ecb *);
151static void ncr53c9x_free_ecb(struct ncr53c9x_softc *,
152 struct ncr53c9x_ecb *);
153static void ncr53c9x_wrfifo(struct ncr53c9x_softc *, u_char *, int);
154static int ncr53c9x_rdfifo(struct ncr53c9x_softc *, int);
155
156static struct ncr53c9x_ecb *ncr53c9x_get_ecb(struct ncr53c9x_softc *);
157static struct ncr53c9x_linfo *ncr53c9x_lunsearch(struct ncr53c9x_tinfo *,
158 int64_t lun);
159
160static __inline void ncr53c9x_readregs(struct ncr53c9x_softc *);
161static __inline int ncr53c9x_stp2cpb(struct ncr53c9x_softc *, int);
162static __inline void ncr53c9x_setsync(struct ncr53c9x_softc *,
163 struct ncr53c9x_tinfo *);
164
165#define NCR_RDFIFO_START 0
166#define NCR_RDFIFO_CONTINUE 1
167
168#define NCR_SET_COUNT(sc, size) do { \
169 NCR_WRITE_REG((sc), NCR_TCL, (size)); \
170 NCR_WRITE_REG((sc), NCR_TCM, (size) >> 8); \
171 if ((sc->sc_cfg2 & NCRCFG2_FE) || \
172 (sc->sc_rev == NCR_VARIANT_FAS366)) { \
173 NCR_WRITE_REG((sc), NCR_TCH, (size) >> 16); \
174 } \
175 if (sc->sc_rev == NCR_VARIANT_FAS366) { \
176 NCR_WRITE_REG(sc, NCR_RCH, 0); \
177 } \
178} while (0)
179
180#ifndef mstohz
181#define mstohz(ms) \
182 (((ms) < 0x20000) ? \
183 ((ms +0u) / 1000u) * hz : \
184 ((ms +0u) * hz) /1000u)
185#endif
186
187/*
188 * Names for the NCR53c9x variants, corresponding to the variant tags
189 * in ncr53c9xvar.h.
190 */
191static const char *ncr53c9x_variant_names[] = {
192 "ESP100",
193 "ESP100A",
194 "ESP200",
195 "NCR53C94",
196 "NCR53C96",
197 "ESP406",
198 "FAS408",
199 "FAS216",
200 "AM53C974",
201 "FAS366/HME",
202 "NCR53C90 (86C01)",
| 108
109#include <sys/param.h>
110#include <sys/systm.h>
111#include <sys/bus.h>
112#include <sys/kernel.h>
113#include <sys/malloc.h>
114#include <sys/resource.h>
115#include <sys/lock.h>
116#include <sys/mutex.h>
117#include <sys/queue.h>
118#include <sys/time.h>
119#include <sys/callout.h>
120
121#include <cam/cam.h>
122#include <cam/cam_ccb.h>
123#include <cam/cam_debug.h>
124#include <cam/cam_sim.h>
125#include <cam/cam_xpt_sim.h>
126#include <cam/scsi/scsi_all.h>
127#include <cam/scsi/scsi_message.h>
128
129#include <dev/esp/ncr53c9xreg.h>
130#include <dev/esp/ncr53c9xvar.h>
131
132int ncr53c9x_debug = NCR_SHOWMISC /*|NCR_SHOWPHASE|NCR_SHOWTRAC|NCR_SHOWCMDS*/;
133#ifdef DEBUG
134int ncr53c9x_notag = 0;
135#endif
136
137static void ncr53c9x_select(struct ncr53c9x_softc *, struct ncr53c9x_ecb *);
138static int ncr53c9x_reselect(struct ncr53c9x_softc *, int, int, int);
139static void ncr53c9x_scsi_reset(struct ncr53c9x_softc *);
140static void ncr53c9x_poll(struct cam_sim *);
141static void ncr53c9x_sched(struct ncr53c9x_softc *);
142static void ncr53c9x_done(struct ncr53c9x_softc *, struct ncr53c9x_ecb *);
143static void ncr53c9x_msgin(struct ncr53c9x_softc *);
144static void ncr53c9x_msgout(struct ncr53c9x_softc *);
145static void ncr53c9x_timeout(void *arg);
146static void ncr53c9x_watch(void *arg);
147static void ncr53c9x_abort(struct ncr53c9x_softc *, struct ncr53c9x_ecb *);
148static void ncr53c9x_dequeue(struct ncr53c9x_softc *,
149 struct ncr53c9x_ecb *);
150static void ncr53c9x_sense(struct ncr53c9x_softc *, struct ncr53c9x_ecb *);
151static void ncr53c9x_free_ecb(struct ncr53c9x_softc *,
152 struct ncr53c9x_ecb *);
153static void ncr53c9x_wrfifo(struct ncr53c9x_softc *, u_char *, int);
154static int ncr53c9x_rdfifo(struct ncr53c9x_softc *, int);
155
156static struct ncr53c9x_ecb *ncr53c9x_get_ecb(struct ncr53c9x_softc *);
157static struct ncr53c9x_linfo *ncr53c9x_lunsearch(struct ncr53c9x_tinfo *,
158 int64_t lun);
159
160static __inline void ncr53c9x_readregs(struct ncr53c9x_softc *);
161static __inline int ncr53c9x_stp2cpb(struct ncr53c9x_softc *, int);
162static __inline void ncr53c9x_setsync(struct ncr53c9x_softc *,
163 struct ncr53c9x_tinfo *);
164
165#define NCR_RDFIFO_START 0
166#define NCR_RDFIFO_CONTINUE 1
167
168#define NCR_SET_COUNT(sc, size) do { \
169 NCR_WRITE_REG((sc), NCR_TCL, (size)); \
170 NCR_WRITE_REG((sc), NCR_TCM, (size) >> 8); \
171 if ((sc->sc_cfg2 & NCRCFG2_FE) || \
172 (sc->sc_rev == NCR_VARIANT_FAS366)) { \
173 NCR_WRITE_REG((sc), NCR_TCH, (size) >> 16); \
174 } \
175 if (sc->sc_rev == NCR_VARIANT_FAS366) { \
176 NCR_WRITE_REG(sc, NCR_RCH, 0); \
177 } \
178} while (0)
179
180#ifndef mstohz
181#define mstohz(ms) \
182 (((ms) < 0x20000) ? \
183 ((ms +0u) / 1000u) * hz : \
184 ((ms +0u) * hz) /1000u)
185#endif
186
187/*
188 * Names for the NCR53c9x variants, corresponding to the variant tags
189 * in ncr53c9xvar.h.
190 */
191static const char *ncr53c9x_variant_names[] = {
192 "ESP100",
193 "ESP100A",
194 "ESP200",
195 "NCR53C94",
196 "NCR53C96",
197 "ESP406",
198 "FAS408",
199 "FAS216",
200 "AM53C974",
201 "FAS366/HME",
202 "NCR53C90 (86C01)",
|
| 203 "FAS100A",
204 "FAS236",
|
203};
204
205/*
206 * Search linked list for LUN info by LUN id.
207 */
208static struct ncr53c9x_linfo *
209ncr53c9x_lunsearch(struct ncr53c9x_tinfo *ti, int64_t lun)
210{
211 struct ncr53c9x_linfo *li;
212 LIST_FOREACH(li, &ti->luns, link)
213 if (li->lun == lun)
214 return (li);
215 return (NULL);
216}
217
218/*
219 * Attach this instance, and then all the sub-devices.
220 */
221int
222ncr53c9x_attach(struct ncr53c9x_softc *sc)
223{
224 struct cam_devq *devq;
225 struct cam_sim *sim;
226 struct cam_path *path;
227 struct ncr53c9x_ecb *ecb;
| 205};
206
207/*
208 * Search linked list for LUN info by LUN id.
209 */
210static struct ncr53c9x_linfo *
211ncr53c9x_lunsearch(struct ncr53c9x_tinfo *ti, int64_t lun)
212{
213 struct ncr53c9x_linfo *li;
214 LIST_FOREACH(li, &ti->luns, link)
215 if (li->lun == lun)
216 return (li);
217 return (NULL);
218}
219
220/*
221 * Attach this instance, and then all the sub-devices.
222 */
223int
224ncr53c9x_attach(struct ncr53c9x_softc *sc)
225{
226 struct cam_devq *devq;
227 struct cam_sim *sim;
228 struct cam_path *path;
229 struct ncr53c9x_ecb *ecb;
|
228 int i;
| 230 int error, i;
|
229
230 mtx_init(&sc->sc_lock, "ncr", "ncr53c9x lock", MTX_DEF);
231
232 /*
233 * Note, the front-end has set us up to print the chip variation.
234 */
235 if (sc->sc_rev >= NCR_VARIANT_MAX) {
236 device_printf(sc->sc_dev, "unknown variant %d, devices not "
237 "attached\n", sc->sc_rev);
238 return (EINVAL);
239 }
240
241 device_printf(sc->sc_dev, "%s, %dMHz, SCSI ID %d\n",
242 ncr53c9x_variant_names[sc->sc_rev], sc->sc_freq, sc->sc_id);
243
244 sc->sc_ntarg = (sc->sc_rev == NCR_VARIANT_FAS366) ? 16 : 8;
245
246 /*
247 * Allocate SCSI message buffers.
248 * Front-ends can override allocation to avoid alignment
249 * handling in the DMA engines. Note that that ncr53c9x_msgout()
250 * can request a 1 byte DMA transfer.
251 */
| 231
232 mtx_init(&sc->sc_lock, "ncr", "ncr53c9x lock", MTX_DEF);
233
234 /*
235 * Note, the front-end has set us up to print the chip variation.
236 */
237 if (sc->sc_rev >= NCR_VARIANT_MAX) {
238 device_printf(sc->sc_dev, "unknown variant %d, devices not "
239 "attached\n", sc->sc_rev);
240 return (EINVAL);
241 }
242
243 device_printf(sc->sc_dev, "%s, %dMHz, SCSI ID %d\n",
244 ncr53c9x_variant_names[sc->sc_rev], sc->sc_freq, sc->sc_id);
245
246 sc->sc_ntarg = (sc->sc_rev == NCR_VARIANT_FAS366) ? 16 : 8;
247
248 /*
249 * Allocate SCSI message buffers.
250 * Front-ends can override allocation to avoid alignment
251 * handling in the DMA engines. Note that that ncr53c9x_msgout()
252 * can request a 1 byte DMA transfer.
253 */
|
252 if (sc->sc_omess == NULL)
| 254 if (sc->sc_omess == NULL) {
255 sc->sc_omess_self = 1;
|
253 sc->sc_omess = malloc(NCR_MAX_MSG_LEN, M_DEVBUF, M_NOWAIT);
| 256 sc->sc_omess = malloc(NCR_MAX_MSG_LEN, M_DEVBUF, M_NOWAIT);
|
| 257 if (sc->sc_omess == NULL) {
258 device_printf(sc->sc_dev,
259 "cannot allocate MSGOUT buffer\n");
260 return (ENOMEM);
261 }
262 } else
263 sc->sc_omess_self = 0;
|
254
| 264
|
255 if (sc->sc_imess == NULL)
| 265 if (sc->sc_imess == NULL) {
266 sc->sc_imess_self = 1;
|
256 sc->sc_imess = malloc(NCR_MAX_MSG_LEN + 1, M_DEVBUF, M_NOWAIT);
| 267 sc->sc_imess = malloc(NCR_MAX_MSG_LEN + 1, M_DEVBUF, M_NOWAIT);
|
| 268 if (sc->sc_imess == NULL) {
269 device_printf(sc->sc_dev,
270 "cannot allocate MSGIN buffer\n");
271 error = ENOMEM;
272 goto fail_omess;
273 }
274 } else
275 sc->sc_imess_self = 0;
|
257
258 sc->sc_tinfo = malloc(sc->sc_ntarg * sizeof(sc->sc_tinfo[0]),
259 M_DEVBUF, M_NOWAIT | M_ZERO);
| 276
277 sc->sc_tinfo = malloc(sc->sc_ntarg * sizeof(sc->sc_tinfo[0]),
278 M_DEVBUF, M_NOWAIT | M_ZERO);
|
260
261 if (!sc->sc_omess || !sc->sc_imess || !sc->sc_tinfo) {
262 printf("out of memory\n");
263 return (ENOMEM);
| 279 if (sc->sc_tinfo == NULL) {
280 device_printf(sc->sc_dev,
281 "cannot allocate target info buffer\n");
282 error = ENOMEM;
283 goto fail_imess;
|
264 }
265
266 callout_init(&sc->sc_watchdog, 0);
267
268 /*
269 * Treat NCR53C90 with the 86C01 DMA chip exactly as ESP100
270 * from now on.
271 */
272 if (sc->sc_rev == NCR_VARIANT_NCR53C90_86C01)
273 sc->sc_rev = NCR_VARIANT_ESP100;
274
275 sc->sc_ccf = FREQTOCCF(sc->sc_freq);
276
277 /* The value *must not* be == 1. Make it 2 */
278 if (sc->sc_ccf == 1)
279 sc->sc_ccf = 2;
280
281 /*
282 * The recommended timeout is 250ms. This register is loaded
283 * with a value calculated as follows, from the docs:
284 *
285 * (timout period) x (CLK frequency)
286 * reg = -------------------------------------
287 * 8192 x (Clock Conversion Factor)
288 *
289 * Since CCF has a linear relation to CLK, this generally computes
290 * to the constant of 153.
291 */
292 sc->sc_timeout = ((250 * 1000) * sc->sc_freq) / (8192 * sc->sc_ccf);
293
294 /* CCF register only has 3 bits; 0 is actually 8 */
295 sc->sc_ccf &= 7;
296
297 /*
298 * Register with CAM
299 */
300 devq = cam_simq_alloc(sc->sc_ntarg);
| 284 }
285
286 callout_init(&sc->sc_watchdog, 0);
287
288 /*
289 * Treat NCR53C90 with the 86C01 DMA chip exactly as ESP100
290 * from now on.
291 */
292 if (sc->sc_rev == NCR_VARIANT_NCR53C90_86C01)
293 sc->sc_rev = NCR_VARIANT_ESP100;
294
295 sc->sc_ccf = FREQTOCCF(sc->sc_freq);
296
297 /* The value *must not* be == 1. Make it 2 */
298 if (sc->sc_ccf == 1)
299 sc->sc_ccf = 2;
300
301 /*
302 * The recommended timeout is 250ms. This register is loaded
303 * with a value calculated as follows, from the docs:
304 *
305 * (timout period) x (CLK frequency)
306 * reg = -------------------------------------
307 * 8192 x (Clock Conversion Factor)
308 *
309 * Since CCF has a linear relation to CLK, this generally computes
310 * to the constant of 153.
311 */
312 sc->sc_timeout = ((250 * 1000) * sc->sc_freq) / (8192 * sc->sc_ccf);
313
314 /* CCF register only has 3 bits; 0 is actually 8 */
315 sc->sc_ccf &= 7;
316
317 /*
318 * Register with CAM
319 */
320 devq = cam_simq_alloc(sc->sc_ntarg);
|
301 if (devq == NULL)
302 return (ENOMEM);
| 321 if (devq == NULL) {
322 device_printf(sc->sc_dev, "cannot allocate device queue\n");
323 error = ENOMEM;
324 goto fail_tinfo;
325 }
|
303
304 sim = cam_sim_alloc(ncr53c9x_action, ncr53c9x_poll, "esp", sc,
305 device_get_unit(sc->sc_dev), 1,
306 NCR_TAG_DEPTH, devq);
307 if (sim == NULL) {
| 326
327 sim = cam_sim_alloc(ncr53c9x_action, ncr53c9x_poll, "esp", sc,
328 device_get_unit(sc->sc_dev), 1,
329 NCR_TAG_DEPTH, devq);
330 if (sim == NULL) {
|
308 cam_simq_free(devq);
309 return (ENOMEM);
| 331 device_printf(sc->sc_dev, "cannot allocate SIM entry\n");
332 error = ENOMEM;
333 goto fail_devq;
|
310 }
311 if (xpt_bus_register(sim, 0) != CAM_SUCCESS) {
| 334 }
335 if (xpt_bus_register(sim, 0) != CAM_SUCCESS) {
|
312 cam_sim_free(sim, TRUE);
313 return (EIO);
| 336 device_printf(sc->sc_dev, "cannot register bus\n");
337 error = EIO;
338 goto fail_sim;
|
314 }
315
316 if (xpt_create_path(&path, NULL, cam_sim_path(sim),
317 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD)
318 != CAM_REQ_CMP) {
| 339 }
340
341 if (xpt_create_path(&path, NULL, cam_sim_path(sim),
342 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD)
343 != CAM_REQ_CMP) {
|
319 xpt_bus_deregister(cam_sim_path(sim));
320 cam_sim_free(sim, TRUE);
321 return (EIO);
| 344 device_printf(sc->sc_dev, "cannot create path\n");
345 error = EIO;
346 goto fail_bus;
|
322 }
323
324 sc->sc_sim = sim;
325 sc->sc_path = path;
326
327 /* Reset state & bus */
328#if 0
329 sc->sc_cfflags = sc->sc_dev.dv_cfdata->cf_flags;
330#endif
331 sc->sc_state = 0;
332 ncr53c9x_init(sc, 1);
333
334 TAILQ_INIT(&sc->free_list);
335 if ((sc->ecb_array = malloc(sizeof(struct ncr53c9x_ecb) * NCR_TAG_DEPTH,
336 M_DEVBUF, M_NOWAIT|M_ZERO)) == NULL) {
337 device_printf(sc->sc_dev, "cannot allocate ECB array\n");
| 347 }
348
349 sc->sc_sim = sim;
350 sc->sc_path = path;
351
352 /* Reset state & bus */
353#if 0
354 sc->sc_cfflags = sc->sc_dev.dv_cfdata->cf_flags;
355#endif
356 sc->sc_state = 0;
357 ncr53c9x_init(sc, 1);
358
359 TAILQ_INIT(&sc->free_list);
360 if ((sc->ecb_array = malloc(sizeof(struct ncr53c9x_ecb) * NCR_TAG_DEPTH,
361 M_DEVBUF, M_NOWAIT|M_ZERO)) == NULL) {
362 device_printf(sc->sc_dev, "cannot allocate ECB array\n");
|
338 return (ENOMEM);
| 363 error = ENOMEM;
364 goto fail_path;
|
339 }
340 for (i = 0; i < NCR_TAG_DEPTH; i++) {
341 ecb = &sc->ecb_array[i];
342 ecb->sc = sc;
343 ecb->tag_id = i;
344 TAILQ_INSERT_HEAD(&sc->free_list, ecb, free_links);
345 }
346
347 callout_reset(&sc->sc_watchdog, 60*hz, ncr53c9x_watch, sc);
348
349 return (0);
| 365 }
366 for (i = 0; i < NCR_TAG_DEPTH; i++) {
367 ecb = &sc->ecb_array[i];
368 ecb->sc = sc;
369 ecb->tag_id = i;
370 TAILQ_INSERT_HEAD(&sc->free_list, ecb, free_links);
371 }
372
373 callout_reset(&sc->sc_watchdog, 60*hz, ncr53c9x_watch, sc);
374
375 return (0);
|
| 376
377fail_path:
378 xpt_free_path(path);
379fail_bus:
380 xpt_bus_deregister(cam_sim_path(sim));
381fail_sim:
382 cam_sim_free(sim, TRUE);
383fail_devq:
384 cam_simq_free(devq);
385fail_tinfo:
386 free(sc->sc_tinfo, M_DEVBUF);
387fail_imess:
388 if (sc->sc_imess_self)
389 free(sc->sc_imess, M_DEVBUF);
390fail_omess:
391 if (sc->sc_omess_self)
392 free(sc->sc_omess, M_DEVBUF);
393 return (error);
|
350}
351
352int
| 394}
395
396int
|
353ncr53c9x_detach(struct ncr53c9x_softc *sc, int flags)
| 397ncr53c9x_detach(struct ncr53c9x_softc *sc)
|
354{
355
| 398{
399
|
356#if 0 /* don't allow detach for now */
357 free(sc->sc_imess, M_DEVBUF);
358 free(sc->sc_omess, M_DEVBUF);
359#endif
| 400 callout_drain(&sc->sc_watchdog);
401 mtx_lock(&sc->sc_lock);
402 ncr53c9x_init(sc, 1);
403 mtx_unlock(&sc->sc_lock);
404 xpt_free_path(sc->sc_path);
405 xpt_bus_deregister(cam_sim_path(sc->sc_sim));
406 cam_sim_free(sc->sc_sim, TRUE);
407 free(sc->ecb_array, M_DEVBUF);
408 free(sc->sc_tinfo, M_DEVBUF);
409 if (sc->sc_imess_self)
410 free(sc->sc_imess, M_DEVBUF);
411 if (sc->sc_omess_self)
412 free(sc->sc_omess, M_DEVBUF);
413 mtx_destroy(&sc->sc_lock);
|
360
| 414
|
361 return (EINVAL);
| 415 return (0);
|
362}
363
364/*
365 * This is the generic ncr53c9x reset function. It does not reset the SCSI bus,
366 * only this controller, but kills any on-going commands, and also stops
367 * and resets the DMA.
368 *
369 * After reset, registers are loaded with the defaults from the attach
370 * routine above.
371 */
372void
373ncr53c9x_reset(struct ncr53c9x_softc *sc)
374{
375
376 /* reset DMA first */
377 NCRDMA_RESET(sc);
378
379 /* reset SCSI chip */
380 NCRCMD(sc, NCRCMD_RSTCHIP);
381 NCRCMD(sc, NCRCMD_NOP);
382 DELAY(500);
383
384 /* do these backwards, and fall through */
385 switch (sc->sc_rev) {
386 case NCR_VARIANT_ESP406:
387 case NCR_VARIANT_FAS408:
388 NCR_WRITE_REG(sc, NCR_CFG5, sc->sc_cfg5 | NCRCFG5_SINT);
389 NCR_WRITE_REG(sc, NCR_CFG4, sc->sc_cfg4);
390 case NCR_VARIANT_AM53C974:
| 416}
417
418/*
419 * This is the generic ncr53c9x reset function. It does not reset the SCSI bus,
420 * only this controller, but kills any on-going commands, and also stops
421 * and resets the DMA.
422 *
423 * After reset, registers are loaded with the defaults from the attach
424 * routine above.
425 */
426void
427ncr53c9x_reset(struct ncr53c9x_softc *sc)
428{
429
430 /* reset DMA first */
431 NCRDMA_RESET(sc);
432
433 /* reset SCSI chip */
434 NCRCMD(sc, NCRCMD_RSTCHIP);
435 NCRCMD(sc, NCRCMD_NOP);
436 DELAY(500);
437
438 /* do these backwards, and fall through */
439 switch (sc->sc_rev) {
440 case NCR_VARIANT_ESP406:
441 case NCR_VARIANT_FAS408:
442 NCR_WRITE_REG(sc, NCR_CFG5, sc->sc_cfg5 | NCRCFG5_SINT);
443 NCR_WRITE_REG(sc, NCR_CFG4, sc->sc_cfg4);
444 case NCR_VARIANT_AM53C974:
|
| 445 case NCR_VARIANT_FAS100A:
|
391 case NCR_VARIANT_FAS216:
| 446 case NCR_VARIANT_FAS216:
|
| 447 case NCR_VARIANT_FAS236:
|
392 case NCR_VARIANT_NCR53C94:
393 case NCR_VARIANT_NCR53C96:
394 case NCR_VARIANT_ESP200:
395 sc->sc_features |= NCR_F_HASCFG3;
396 NCR_WRITE_REG(sc, NCR_CFG3, sc->sc_cfg3);
397 case NCR_VARIANT_ESP100A:
398 sc->sc_features |= NCR_F_SELATN3;
399 NCR_WRITE_REG(sc, NCR_CFG2, sc->sc_cfg2);
400 case NCR_VARIANT_ESP100:
401 NCR_WRITE_REG(sc, NCR_CFG1, sc->sc_cfg1);
402 NCR_WRITE_REG(sc, NCR_CCF, sc->sc_ccf);
403 NCR_WRITE_REG(sc, NCR_SYNCOFF, 0);
404 NCR_WRITE_REG(sc, NCR_TIMEOUT, sc->sc_timeout);
405 break;
406
407 case NCR_VARIANT_FAS366:
408 sc->sc_features |=
409 NCR_F_HASCFG3 | NCR_F_FASTSCSI | NCR_F_SELATN3;
410 sc->sc_cfg3 = NCRFASCFG3_FASTCLK | NCRFASCFG3_OBAUTO;
411 sc->sc_cfg3_fscsi = NCRFASCFG3_FASTSCSI;
412 NCR_WRITE_REG(sc, NCR_CFG3, sc->sc_cfg3);
413 sc->sc_cfg2 = 0; /* NCRCFG2_HMEFE| NCRCFG2_HME32 */
414 NCR_WRITE_REG(sc, NCR_CFG2, sc->sc_cfg2);
415 NCR_WRITE_REG(sc, NCR_CFG1, sc->sc_cfg1);
416 NCR_WRITE_REG(sc, NCR_CCF, sc->sc_ccf);
417 NCR_WRITE_REG(sc, NCR_SYNCOFF, 0);
418 NCR_WRITE_REG(sc, NCR_TIMEOUT, sc->sc_timeout);
419 break;
420
421 default:
422 device_printf(sc->sc_dev, "unknown revision code, "
423 "assuming ESP100\n");
424 NCR_WRITE_REG(sc, NCR_CFG1, sc->sc_cfg1);
425 NCR_WRITE_REG(sc, NCR_CCF, sc->sc_ccf);
426 NCR_WRITE_REG(sc, NCR_SYNCOFF, 0);
427 NCR_WRITE_REG(sc, NCR_TIMEOUT, sc->sc_timeout);
428 }
429
430 if (sc->sc_rev == NCR_VARIANT_AM53C974)
431 NCR_WRITE_REG(sc, NCR_AMDCFG4, sc->sc_cfg4);
432
433#if 0
434 device_printf(sc->sc_dev, "ncr53c9x_reset: revision %d\n",
435 sc->sc_rev);
436 device_printf(sc->sc_dev, "ncr53c9x_reset: cfg1 0x%x, cfg2 0x%x, "
437 "cfg3 0x%x, ccf 0x%x, timeout 0x%x\n",
438 sc->sc_cfg1, sc->sc_cfg2, sc->sc_cfg3, sc->sc_ccf, sc->sc_timeout);
439#endif
440}
441
442/*
443 * Reset the SCSI bus, but not the chip
444 */
445static void
446ncr53c9x_scsi_reset(struct ncr53c9x_softc *sc)
447{
448
449 (*sc->sc_glue->gl_dma_stop)(sc);
450
451 NCR_MISC(("%s: resetting SCSI bus\n", device_get_nameunit(sc->sc_dev)));
452 NCRCMD(sc, NCRCMD_RSTSCSI);
453 DELAY(250000); /* Give the bus a fighting chance to settle */
454}
455
456/*
457 * Initialize ncr53c9x state machine
458 */
459void
460ncr53c9x_init(struct ncr53c9x_softc *sc, int doreset)
461{
462 struct ncr53c9x_ecb *ecb;
463 struct ncr53c9x_linfo *li;
464 int i, r;
465
466 NCR_MISC(("[NCR_INIT(%d) %d] ", doreset, sc->sc_state));
467
468 if (sc->sc_state == 0) {
469 /* First time through; initialize. */
470
471 TAILQ_INIT(&sc->ready_list);
472 sc->sc_nexus = NULL;
473 memset(sc->sc_tinfo, 0, sizeof(sc->sc_tinfo));
474 for (r = 0; r < sc->sc_ntarg; r++) {
475 LIST_INIT(&sc->sc_tinfo[r].luns);
476 }
477 } else {
478 /* Cancel any active commands. */
479 sc->sc_state = NCR_CLEANING;
480 sc->sc_msgify = 0;
481 if ((ecb = sc->sc_nexus) != NULL) {
482 ecb->ccb->ccb_h.status = CAM_CMD_TIMEOUT;
483 ncr53c9x_done(sc, ecb);
484 }
485 /* Cancel outstanding disconnected commands on each LUN */
486 for (r = 0; r < sc->sc_ntarg; r++) {
487 LIST_FOREACH(li, &sc->sc_tinfo[r].luns, link) {
488 if ((ecb = li->untagged) != NULL) {
489 li->untagged = NULL;
490 /*
491 * XXXXXXX
492 *
493 * Should we terminate a command
494 * that never reached the disk?
495 */
496 li->busy = 0;
497 ecb->ccb->ccb_h.status =
498 CAM_CMD_TIMEOUT;
499 ncr53c9x_done(sc, ecb);
500 }
501 for (i = 0; i < 256; i++)
502 if ((ecb = li->queued[i])) {
503 li->queued[i] = NULL;
504 ecb->ccb->ccb_h.status =
505 CAM_CMD_TIMEOUT;
506 ncr53c9x_done(sc, ecb);
507 }
508 li->used = 0;
509 }
510 }
511 }
512
513 /*
514 * reset the chip to a known state
515 */
516 ncr53c9x_reset(sc);
517
| 448 case NCR_VARIANT_NCR53C94:
449 case NCR_VARIANT_NCR53C96:
450 case NCR_VARIANT_ESP200:
451 sc->sc_features |= NCR_F_HASCFG3;
452 NCR_WRITE_REG(sc, NCR_CFG3, sc->sc_cfg3);
453 case NCR_VARIANT_ESP100A:
454 sc->sc_features |= NCR_F_SELATN3;
455 NCR_WRITE_REG(sc, NCR_CFG2, sc->sc_cfg2);
456 case NCR_VARIANT_ESP100:
457 NCR_WRITE_REG(sc, NCR_CFG1, sc->sc_cfg1);
458 NCR_WRITE_REG(sc, NCR_CCF, sc->sc_ccf);
459 NCR_WRITE_REG(sc, NCR_SYNCOFF, 0);
460 NCR_WRITE_REG(sc, NCR_TIMEOUT, sc->sc_timeout);
461 break;
462
463 case NCR_VARIANT_FAS366:
464 sc->sc_features |=
465 NCR_F_HASCFG3 | NCR_F_FASTSCSI | NCR_F_SELATN3;
466 sc->sc_cfg3 = NCRFASCFG3_FASTCLK | NCRFASCFG3_OBAUTO;
467 sc->sc_cfg3_fscsi = NCRFASCFG3_FASTSCSI;
468 NCR_WRITE_REG(sc, NCR_CFG3, sc->sc_cfg3);
469 sc->sc_cfg2 = 0; /* NCRCFG2_HMEFE| NCRCFG2_HME32 */
470 NCR_WRITE_REG(sc, NCR_CFG2, sc->sc_cfg2);
471 NCR_WRITE_REG(sc, NCR_CFG1, sc->sc_cfg1);
472 NCR_WRITE_REG(sc, NCR_CCF, sc->sc_ccf);
473 NCR_WRITE_REG(sc, NCR_SYNCOFF, 0);
474 NCR_WRITE_REG(sc, NCR_TIMEOUT, sc->sc_timeout);
475 break;
476
477 default:
478 device_printf(sc->sc_dev, "unknown revision code, "
479 "assuming ESP100\n");
480 NCR_WRITE_REG(sc, NCR_CFG1, sc->sc_cfg1);
481 NCR_WRITE_REG(sc, NCR_CCF, sc->sc_ccf);
482 NCR_WRITE_REG(sc, NCR_SYNCOFF, 0);
483 NCR_WRITE_REG(sc, NCR_TIMEOUT, sc->sc_timeout);
484 }
485
486 if (sc->sc_rev == NCR_VARIANT_AM53C974)
487 NCR_WRITE_REG(sc, NCR_AMDCFG4, sc->sc_cfg4);
488
489#if 0
490 device_printf(sc->sc_dev, "ncr53c9x_reset: revision %d\n",
491 sc->sc_rev);
492 device_printf(sc->sc_dev, "ncr53c9x_reset: cfg1 0x%x, cfg2 0x%x, "
493 "cfg3 0x%x, ccf 0x%x, timeout 0x%x\n",
494 sc->sc_cfg1, sc->sc_cfg2, sc->sc_cfg3, sc->sc_ccf, sc->sc_timeout);
495#endif
496}
497
498/*
499 * Reset the SCSI bus, but not the chip
500 */
501static void
502ncr53c9x_scsi_reset(struct ncr53c9x_softc *sc)
503{
504
505 (*sc->sc_glue->gl_dma_stop)(sc);
506
507 NCR_MISC(("%s: resetting SCSI bus\n", device_get_nameunit(sc->sc_dev)));
508 NCRCMD(sc, NCRCMD_RSTSCSI);
509 DELAY(250000); /* Give the bus a fighting chance to settle */
510}
511
512/*
513 * Initialize ncr53c9x state machine
514 */
515void
516ncr53c9x_init(struct ncr53c9x_softc *sc, int doreset)
517{
518 struct ncr53c9x_ecb *ecb;
519 struct ncr53c9x_linfo *li;
520 int i, r;
521
522 NCR_MISC(("[NCR_INIT(%d) %d] ", doreset, sc->sc_state));
523
524 if (sc->sc_state == 0) {
525 /* First time through; initialize. */
526
527 TAILQ_INIT(&sc->ready_list);
528 sc->sc_nexus = NULL;
529 memset(sc->sc_tinfo, 0, sizeof(sc->sc_tinfo));
530 for (r = 0; r < sc->sc_ntarg; r++) {
531 LIST_INIT(&sc->sc_tinfo[r].luns);
532 }
533 } else {
534 /* Cancel any active commands. */
535 sc->sc_state = NCR_CLEANING;
536 sc->sc_msgify = 0;
537 if ((ecb = sc->sc_nexus) != NULL) {
538 ecb->ccb->ccb_h.status = CAM_CMD_TIMEOUT;
539 ncr53c9x_done(sc, ecb);
540 }
541 /* Cancel outstanding disconnected commands on each LUN */
542 for (r = 0; r < sc->sc_ntarg; r++) {
543 LIST_FOREACH(li, &sc->sc_tinfo[r].luns, link) {
544 if ((ecb = li->untagged) != NULL) {
545 li->untagged = NULL;
546 /*
547 * XXXXXXX
548 *
549 * Should we terminate a command
550 * that never reached the disk?
551 */
552 li->busy = 0;
553 ecb->ccb->ccb_h.status =
554 CAM_CMD_TIMEOUT;
555 ncr53c9x_done(sc, ecb);
556 }
557 for (i = 0; i < 256; i++)
558 if ((ecb = li->queued[i])) {
559 li->queued[i] = NULL;
560 ecb->ccb->ccb_h.status =
561 CAM_CMD_TIMEOUT;
562 ncr53c9x_done(sc, ecb);
563 }
564 li->used = 0;
565 }
566 }
567 }
568
569 /*
570 * reset the chip to a known state
571 */
572 ncr53c9x_reset(sc);
573
|
| 574 sc->sc_flags = 0;
575 sc->sc_msgpriq = sc->sc_msgout = sc->sc_msgoutq = 0;
|
518 sc->sc_phase = sc->sc_prevphase = INVALID_PHASE;
| 576 sc->sc_phase = sc->sc_prevphase = INVALID_PHASE;
|
| 577
|
519 for (r = 0; r < sc->sc_ntarg; r++) {
520 struct ncr53c9x_tinfo *ti = &sc->sc_tinfo[r];
521/* XXX - config flags per target: low bits: no reselect; high bits: no synch */
522
523 ti->flags = ((sc->sc_minsync && !(sc->sc_cfflags & (1<<((r&7)+8))))
524 ? 0 : T_SYNCHOFF) |
525 ((sc->sc_cfflags & (1<<(r&7))) ? T_RSELECTOFF : 0);
526#ifdef DEBUG
527 if (ncr53c9x_notag)
528 ti->flags &= ~T_TAG;
529#endif
530 ti->period = sc->sc_minsync;
531 ti->offset = 0;
532 ti->cfg3 = 0;
533 }
534
535 if (doreset) {
536 sc->sc_state = NCR_SBR;
537 NCRCMD(sc, NCRCMD_RSTSCSI);
538 } else {
539 sc->sc_state = NCR_IDLE;
540 ncr53c9x_sched(sc);
541 }
542}
543
544/*
545 * Read the NCR registers, and save their contents for later use.
546 * NCR_STAT, NCR_STEP & NCR_INTR are mostly zeroed out when reading
547 * NCR_INTR - so make sure it is the last read.
548 *
549 * I think that (from reading the docs) most bits in these registers
550 * only make sense when he DMA CSR has an interrupt showing. Call only
551 * if an interrupt is pending.
552 */
553static __inline void
554ncr53c9x_readregs(struct ncr53c9x_softc *sc)
555{
556
557 sc->sc_espstat = NCR_READ_REG(sc, NCR_STAT);
558 /* Only the stepo bits are of interest */
559 sc->sc_espstep = NCR_READ_REG(sc, NCR_STEP) & NCRSTEP_MASK;
560
561 if (sc->sc_rev == NCR_VARIANT_FAS366)
562 sc->sc_espstat2 = NCR_READ_REG(sc, NCR_STAT2);
563
564 sc->sc_espintr = NCR_READ_REG(sc, NCR_INTR);
565
566 if (sc->sc_glue->gl_clear_latched_intr != NULL)
567 (*sc->sc_glue->gl_clear_latched_intr)(sc);
568
569 /*
570 * Determine the SCSI bus phase, return either a real SCSI bus phase
571 * or some pseudo phase we use to detect certain exceptions.
572 */
573
574 sc->sc_phase = (sc->sc_espintr & NCRINTR_DIS) ?
575 /* Disconnected */ BUSFREE_PHASE : sc->sc_espstat & NCRSTAT_PHASE;
576
577 NCR_INTS(("regs[intr=%02x,stat=%02x,step=%02x,stat2=%02x] ",
578 sc->sc_espintr, sc->sc_espstat, sc->sc_espstep, sc->sc_espstat2));
579}
580
581/*
582 * Convert Synchronous Transfer Period to chip register Clock Per Byte value.
583 */
584static __inline int
585ncr53c9x_stp2cpb(struct ncr53c9x_softc *sc, int period)
586{
587 int v;
588 v = (sc->sc_freq * period) / 250;
589 if (ncr53c9x_cpb2stp(sc, v) < period)
590 /* Correct round-down error */
591 v++;
592 return (v);
593}
594
595static __inline void
596ncr53c9x_setsync(struct ncr53c9x_softc *sc, struct ncr53c9x_tinfo *ti)
597{
598 u_char syncoff, synctp;
599 u_char cfg3 = sc->sc_cfg3 | ti->cfg3;
600
601 if (ti->flags & T_SYNCMODE) {
602 syncoff = ti->offset;
603 synctp = ncr53c9x_stp2cpb(sc, ti->period);
604 if (sc->sc_features & NCR_F_FASTSCSI) {
605 /*
606 * If the period is 200ns or less (ti->period <= 50),
607 * put the chip in Fast SCSI mode.
608 */
609 if (ti->period <= 50)
610 /*
611 * There are (at least) 4 variations of the
612 * configuration 3 register. The drive attach
613 * routine sets the appropriate bit to put the
614 * chip into Fast SCSI mode so that it doesn't
615 * have to be figured out here each time.
616 */
617 cfg3 |= sc->sc_cfg3_fscsi;
618 }
619
620 /*
621 * Am53c974 requires different SYNCTP values when the
622 * FSCSI bit is off.
623 */
624 if (sc->sc_rev == NCR_VARIANT_AM53C974 &&
625 (cfg3 & NCRAMDCFG3_FSCSI) == 0)
626 synctp--;
627 } else {
628 syncoff = 0;
629 synctp = 0;
630 }
631
632 if (sc->sc_features & NCR_F_HASCFG3)
633 NCR_WRITE_REG(sc, NCR_CFG3, cfg3);
634
635 NCR_WRITE_REG(sc, NCR_SYNCOFF, syncoff);
636 NCR_WRITE_REG(sc, NCR_SYNCTP, synctp);
637}
638
639/*
640 * Send a command to a target, set the driver state to NCR_SELECTING
641 * and let the caller take care of the rest.
642 *
643 * Keeping this as a function allows me to say that this may be done
644 * by DMA instead of programmed I/O soon.
645 */
646static void
647ncr53c9x_select(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
648{
649 int target = ecb->ccb->ccb_h.target_id;
650 int lun = ecb->ccb->ccb_h.target_lun;
651 struct ncr53c9x_tinfo *ti;
652 int tiflags;
653 u_char *cmd;
654 int clen;
655 int selatn3, selatns;
656 size_t dmasize;
657
658 NCR_TRACE(("[ncr53c9x_select(t%d,l%d,cmd:%x,tag:%x,%x)] ",
659 target, lun, ecb->cmd.cmd.opcode, ecb->tag[0], ecb->tag[1]));
660
661 ti = &sc->sc_tinfo[target];
662 tiflags = ti->flags;
663 sc->sc_state = NCR_SELECTING;
664 /*
665 * Schedule the timeout now, the first time we will go away
666 * expecting to come back due to an interrupt, because it is
667 * always possible that the interrupt may never happen.
668 */
669 ecb->ccb->ccb_h.timeout_ch =
670 timeout(ncr53c9x_timeout, ecb, mstohz(ecb->timeout));
671
672 /*
673 * The docs say the target register is never reset, and I
674 * can't think of a better place to set it
675 */
676 if (sc->sc_rev == NCR_VARIANT_FAS366) {
677 NCRCMD(sc, NCRCMD_FLUSH);
678 NCR_WRITE_REG(sc, NCR_SELID, target | NCR_BUSID_HME);
679 } else {
680 NCR_WRITE_REG(sc, NCR_SELID, target);
681 }
682 ncr53c9x_setsync(sc, ti);
683
684 if ((ecb->flags & ECB_SENSE) != 0) {
685 /*
686 * For REQUEST SENSE, we should not send an IDENTIFY or
687 * otherwise mangle the target. There should be no MESSAGE IN
688 * phase.
689 */
690 if (sc->sc_features & NCR_F_DMASELECT) {
691 /* setup DMA transfer for command */
692 dmasize = clen = ecb->clen;
693 sc->sc_cmdlen = clen;
694 sc->sc_cmdp = (caddr_t)&ecb->cmd.cmd;
695
696 /* Program the SCSI counter */
697 NCR_SET_COUNT(sc, dmasize);
698
699 if (sc->sc_rev != NCR_VARIANT_FAS366)
700 NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
701
702 /* And get the targets attention */
703 NCRCMD(sc, NCRCMD_SELNATN | NCRCMD_DMA);
704 NCRDMA_SETUP(sc, &sc->sc_cmdp, &sc->sc_cmdlen, 0,
705 &dmasize);
706 NCRDMA_GO(sc);
707 } else {
708 ncr53c9x_wrfifo(sc, (u_char *)&ecb->cmd.cmd, ecb->clen);
709 NCRCMD(sc, NCRCMD_SELNATN);
710 }
711 return;
712 }
713
714 selatn3 = selatns = 0;
715 if (ecb->tag[0] != 0) {
716 if (sc->sc_features & NCR_F_SELATN3)
717 /* use SELATN3 to send tag messages */
718 selatn3 = 1;
719 else
720 /* We don't have SELATN3; use SELATNS to send tags */
721 selatns = 1;
722 }
723
724 if (ti->flags & T_NEGOTIATE) {
725 /* We have to use SELATNS to send sync/wide messages */
726 selatn3 = 0;
727 selatns = 1;
728 }
729
730 cmd = (u_char *)&ecb->cmd.cmd;
731
732 if (selatn3) {
733 /* We'll use tags with SELATN3 */
734 clen = ecb->clen + 3;
735 cmd -= 3;
736 cmd[0] = MSG_IDENTIFY(lun, 1); /* msg[0] */
737 cmd[1] = ecb->tag[0]; /* msg[1] */
738 cmd[2] = ecb->tag[1]; /* msg[2] */
739 } else {
740 /* We don't have tags, or will send messages with SELATNS */
741 clen = ecb->clen + 1;
742 cmd -= 1;
743 cmd[0] = MSG_IDENTIFY(lun, (tiflags & T_RSELECTOFF) == 0);
744 }
745
746 if ((sc->sc_features & NCR_F_DMASELECT) && !selatns) {
747
748 /* setup DMA transfer for command */
749 dmasize = clen;
750 sc->sc_cmdlen = clen;
751 sc->sc_cmdp = cmd;
752
753 /* Program the SCSI counter */
754 NCR_SET_COUNT(sc, dmasize);
755
756 /* load the count in */
757 /* if (sc->sc_rev != NCR_VARIANT_FAS366) */
758 NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
759
760 /* And get the targets attention */
761 if (selatn3) {
762 sc->sc_msgout = SEND_TAG;
763 sc->sc_flags |= NCR_ATN;
764 NCRCMD(sc, NCRCMD_SELATN3 | NCRCMD_DMA);
765 } else
766 NCRCMD(sc, NCRCMD_SELATN | NCRCMD_DMA);
767 NCRDMA_SETUP(sc, &sc->sc_cmdp, &sc->sc_cmdlen, 0, &dmasize);
768 NCRDMA_GO(sc);
769 return;
770 }
771
772 /*
773 * Who am I? This is where we tell the target that we are
774 * happy for it to disconnect etc.
775 */
776
777 /* Now get the command into the FIFO */
778 ncr53c9x_wrfifo(sc, cmd, clen);
779
780 /* And get the targets attention */
781 if (selatns) {
782 NCR_MSGS(("SELATNS \n"));
783 /* Arbitrate, select and stop after IDENTIFY message */
784 NCRCMD(sc, NCRCMD_SELATNS);
785 } else if (selatn3) {
786 sc->sc_msgout = SEND_TAG;
787 sc->sc_flags |= NCR_ATN;
788 NCRCMD(sc, NCRCMD_SELATN3);
789 } else
790 NCRCMD(sc, NCRCMD_SELATN);
791}
792
793static void
794ncr53c9x_free_ecb(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
795{
796
797 ecb->flags = 0;
798 TAILQ_INSERT_TAIL(&sc->free_list, ecb, free_links);
799 return;
800}
801
802static struct ncr53c9x_ecb *
803ncr53c9x_get_ecb(struct ncr53c9x_softc *sc)
804{
805 struct ncr53c9x_ecb *ecb;
806
807 ecb = TAILQ_FIRST(&sc->free_list);
808 if (ecb) {
809 if (ecb->flags != 0)
810 panic("ecb flags not cleared\n");
811 TAILQ_REMOVE(&sc->free_list, ecb, free_links);
812 ecb->flags = ECB_ALLOC;
813 bzero(&ecb->ccb, sizeof(struct ncr53c9x_ecb) -
814 offsetof(struct ncr53c9x_ecb, ccb));
815 }
816 return (ecb);
817}
818
819/*
820 * DRIVER FUNCTIONS CALLABLE FROM HIGHER LEVEL DRIVERS:
821 */
822
823/*
824 * Start a SCSI-command
825 * This function is called by the higher level SCSI-driver to queue/run
826 * SCSI-commands.
827 */
828
829void
830ncr53c9x_action(struct cam_sim *sim, union ccb *ccb)
831{
832 struct ncr53c9x_softc *sc;
833 struct ncr53c9x_ecb *ecb;
834
835 NCR_TRACE(("[ncr53c9x_action %d]", ccb->ccb_h.func_code));
836
837 sc = cam_sim_softc(sim);
838 mtx_lock(&sc->sc_lock);
839
840 switch (ccb->ccb_h.func_code) {
841 case XPT_RESET_BUS:
842 ncr53c9x_scsi_reset(sc);
843 ccb->ccb_h.status = CAM_REQ_CMP;
844 mtx_unlock(&sc->sc_lock);
845 xpt_done(ccb);
846 return;
847 case XPT_CALC_GEOMETRY:
848 mtx_unlock(&sc->sc_lock);
849 cam_calc_geometry(&ccb->ccg, sc->sc_extended_geom);
850 xpt_done(ccb);
851 return;
852 case XPT_PATH_INQ:
853 {
854 struct ccb_pathinq *cpi = &ccb->cpi;
855
856 cpi->version_num = 1;
857 cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE;
858 cpi->hba_inquiry |=
859 (sc->sc_rev == NCR_VARIANT_FAS366) ? PI_WIDE_16 : 0;
860 cpi->target_sprt = 0;
861 cpi->hba_misc = 0;
862 cpi->hba_eng_cnt = 0;
863 cpi->max_target = sc->sc_ntarg - 1;
864 cpi->max_lun = 8;
865 cpi->initiator_id = sc->sc_id;
866 cpi->bus_id = 0;
867 cpi->base_transfer_speed = 3300;
868 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
869 strncpy(cpi->hba_vid, "Sun", HBA_IDLEN);
870 strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
871 cpi->unit_number = cam_sim_unit(sim);
872 ccb->ccb_h.status = CAM_REQ_CMP;
873 mtx_unlock(&sc->sc_lock);
874 xpt_done(ccb);
875 return;
876 }
877 case XPT_GET_TRAN_SETTINGS:
878 {
879 struct ccb_trans_settings *cts = &ccb->cts;
880 struct ncr53c9x_tinfo *ti;
881
882 ti = &sc->sc_tinfo[ccb->ccb_h.target_id];
883
884 if ((cts->flags & CCB_TRANS_CURRENT_SETTINGS) != 0) {
885 cts->sync_period = ti->period;
886 cts->sync_offset = ti->offset;
887 cts->bus_width = ti->width;
888 if ((ti->flags & T_TAG) != 0)
889 cts->flags |=
890 (CCB_TRANS_DISC_ENB | CCB_TRANS_TAG_ENB);
891 else
892 cts->flags &=
893 ~(CCB_TRANS_DISC_ENB | CCB_TRANS_TAG_ENB);
894 } else {
895 cts->sync_period = sc->sc_maxsync;
896 cts->sync_offset = sc->sc_maxoffset;
897 cts->bus_width = sc->sc_maxwidth;
898 cts->flags |= (CCB_TRANS_DISC_ENB | CCB_TRANS_TAG_ENB);
899 }
900 cts->valid = CCB_TRANS_BUS_WIDTH_VALID |
901 CCB_TRANS_SYNC_RATE_VALID |
902 CCB_TRANS_SYNC_OFFSET_VALID |
903 CCB_TRANS_DISC_VALID |
904 CCB_TRANS_TQ_VALID;
905 ccb->ccb_h.status = CAM_REQ_CMP;
906 mtx_unlock(&sc->sc_lock);
907 xpt_done(ccb);
908 return;
909 }
910 case XPT_ABORT:
911 printf("XPT_ABORT called\n");
912 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
913 mtx_unlock(&sc->sc_lock);
914 xpt_done(ccb);
915 return;
916 case XPT_TERM_IO:
917 printf("XPT_TERM_IO called\n");
918 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
919 mtx_unlock(&sc->sc_lock);
920 xpt_done(ccb);
921 return;
922 case XPT_RESET_DEV:
923 printf("XPT_RESET_DEV called\n");
924 case XPT_SCSI_IO:
925 {
926 struct ccb_scsiio *csio;
927
928 if (ccb->ccb_h.target_id < 0 ||
929 ccb->ccb_h.target_id >= sc->sc_ntarg) {
930 ccb->ccb_h.status = CAM_PATH_INVALID;
931 mtx_unlock(&sc->sc_lock);
932 xpt_done(ccb);
933 return;
934 }
935 /* Get an ECB to use. */
936 ecb = ncr53c9x_get_ecb(sc);
937 /*
938 * This should never happen as we track resources
939 * in the mid-layer.
940 */
941 if (ecb == NULL) {
942 xpt_freeze_simq(sim, 1);
943 ccb->ccb_h.status = CAM_REQUEUE_REQ;
944 printf("unable to allocate ecb\n");
945 mtx_unlock(&sc->sc_lock);
946 xpt_done(ccb);
947 return;
948 }
949
950 /* Initialize ecb */
951 ecb->ccb = ccb;
952 ecb->timeout = ccb->ccb_h.timeout;
953
954 if (ccb->ccb_h.func_code == XPT_RESET_DEV) {
955 ecb->flags |= ECB_RESET;
956 ecb->clen = 0;
957 ecb->dleft = 0;
958 } else {
959 csio = &ccb->csio;
960 if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0)
961 bcopy(csio->cdb_io.cdb_ptr, &ecb->cmd.cmd,
962 csio->cdb_len);
963 else
964 bcopy(csio->cdb_io.cdb_bytes, &ecb->cmd.cmd,
965 csio->cdb_len);
966 ecb->clen = csio->cdb_len;
967 ecb->daddr = csio->data_ptr;
968 ecb->dleft = csio->dxfer_len;
969 }
970 ecb->stat = 0;
971
972 TAILQ_INSERT_TAIL(&sc->ready_list, ecb, chain);
973 ecb->flags |= ECB_READY;
974 if (sc->sc_state == NCR_IDLE)
975 ncr53c9x_sched(sc);
976
977 break;
978 }
979
980 case XPT_SET_TRAN_SETTINGS:
981 {
982 struct ncr53c9x_tinfo *ti;
983 struct ccb_trans_settings *cts = &ccb->cts;
984 int target = ccb->ccb_h.target_id;
985
986 ti = &sc->sc_tinfo[target];
987
988 if ((cts->valid & CCB_TRANS_TQ_VALID) != 0) {
989 if ((sc->sc_cfflags & (1<<((target & 7) + 16))) == 0 &&
990 (cts->flags & CCB_TRANS_TAG_ENB)) {
991 NCR_MISC(("%s: target %d: tagged queuing\n",
992 device_get_nameunit(sc->sc_dev), target));
993 ti->flags |= T_TAG;
994 } else
995 ti->flags &= ~T_TAG;
996 }
997
998 if ((cts->valid & CCB_TRANS_BUS_WIDTH_VALID) != 0) {
999 if (cts->bus_width != 0) {
1000 NCR_MISC(("%s: target %d: wide negotiation\n",
1001 device_get_nameunit(sc->sc_dev), target));
1002 if (sc->sc_rev == NCR_VARIANT_FAS366) {
1003 ti->flags |= T_WIDE;
1004 ti->width = 1;
1005 }
1006 } else {
1007 ti->flags &= ~T_WIDE;
1008 ti->width = 0;
1009 }
1010 ti->flags |= T_NEGOTIATE;
1011 }
1012
1013 if ((cts->valid & CCB_TRANS_SYNC_RATE_VALID) != 0) {
1014 NCR_MISC(("%s: target %d: sync period negotiation\n",
1015 device_get_nameunit(sc->sc_dev), target));
1016 ti->flags |= T_NEGOTIATE;
1017 ti->period = cts->sync_period;
1018 }
1019
1020 if ((cts->valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0) {
1021 NCR_MISC(("%s: target %d: sync offset negotiation\n",
1022 device_get_nameunit(sc->sc_dev), target));
1023 ti->flags |= T_NEGOTIATE;
1024 ti->offset = cts->sync_offset;
1025 }
1026
1027 mtx_unlock(&sc->sc_lock);
1028 ccb->ccb_h.status = CAM_REQ_CMP;
1029 xpt_done(ccb);
1030 return;
1031 }
1032
1033 default:
1034 device_printf(sc->sc_dev, "Unhandled function code %d\n",
1035 ccb->ccb_h.func_code);
1036 ccb->ccb_h.status = CAM_PROVIDE_FAIL;
1037 mtx_unlock(&sc->sc_lock);
1038 xpt_done(ccb);
1039 return;
1040 }
1041
1042 mtx_unlock(&sc->sc_lock);
1043}
1044
1045/*
1046 * Used when interrupt driven I/O is not allowed, e.g. during boot.
1047 */
1048static void
1049ncr53c9x_poll(struct cam_sim *sim)
1050{
1051 struct ncr53c9x_softc *sc;
1052
1053 NCR_TRACE(("[ncr53c9x_poll] "));
1054 sc = cam_sim_softc(sim);
1055 if (NCRDMA_ISINTR(sc)) {
1056 ncr53c9x_intr(sc);
1057 }
1058}
1059
1060/*
1061 * LOW LEVEL SCSI UTILITIES
1062 */
1063
1064/*
1065 * Schedule a scsi operation. This has now been pulled out of the interrupt
1066 * handler so that we may call it from ncr53c9x_scsipi_request and
1067 * ncr53c9x_done. This may save us an unnecessary interrupt just to get
1068 * things going. Should only be called when state == NCR_IDLE and at bio pl.
1069 */
1070static void
1071ncr53c9x_sched(struct ncr53c9x_softc *sc)
1072{
1073 struct ncr53c9x_ecb *ecb;
1074 struct ncr53c9x_tinfo *ti;
1075 struct ncr53c9x_linfo *li;
1076 int lun;
1077 int tag;
1078
1079 NCR_TRACE(("[ncr53c9x_sched] "));
1080 if (sc->sc_state != NCR_IDLE)
1081 panic("ncr53c9x_sched: not IDLE (state=%d)", sc->sc_state);
1082
1083 /*
1084 * Find first ecb in ready queue that is for a target/lunit
1085 * combinations that is not busy.
1086 */
1087 for (ecb = TAILQ_FIRST(&sc->ready_list); ecb != NULL;
1088 ecb = TAILQ_NEXT(ecb, chain)) {
1089 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
1090 lun = ecb->ccb->ccb_h.target_lun;
1091
1092 /* Select type of tag for this command */
1093 if ((ti->flags & (T_RSELECTOFF)) != 0)
1094 tag = 0;
1095 else if ((ti->flags & (T_TAG)) == 0)
1096 tag = 0;
1097 else if ((ecb->flags & ECB_SENSE) != 0)
1098 tag = 0;
1099 else if ((ecb->ccb->ccb_h.flags & CAM_TAG_ACTION_VALID) == 0)
1100 tag = 0;
1101 else if (ecb->ccb->csio.tag_action == CAM_TAG_ACTION_NONE)
1102 tag = 0;
1103 else
1104 tag = ecb->ccb->csio.tag_action;
1105
1106 li = TINFO_LUN(ti, lun);
1107 if (li == NULL) {
1108 /* Initialize LUN info and add to list. */
1109 if ((li = malloc(sizeof(*li),
1110 M_DEVBUF, M_NOWAIT|M_ZERO)) == NULL) {
1111 continue;
1112 }
1113 li->lun = lun;
1114
1115 LIST_INSERT_HEAD(&ti->luns, li, link);
1116 if (lun < NCR_NLUN)
1117 ti->lun[lun] = li;
1118 }
1119 li->last_used = time_second;
1120 if (tag == 0) {
1121 /* Try to issue this as an un-tagged command */
1122 if (li->untagged == NULL)
1123 li->untagged = ecb;
1124 }
1125 if (li->untagged != NULL) {
1126 tag = 0;
1127 if ((li->busy != 1) && li->used == 0) {
1128 /* We need to issue this untagged command now */
1129 ecb = li->untagged;
1130 } else {
1131 /* Not ready yet */
1132 continue;
1133 }
1134 }
1135 ecb->tag[0] = tag;
1136 if (tag != 0) {
1137 li->queued[ecb->tag_id] = ecb;
1138 ecb->tag[1] = ecb->tag_id;
1139 li->used++;
1140 }
1141 if (li->untagged != NULL && (li->busy != 1)) {
1142 li->busy = 1;
1143 TAILQ_REMOVE(&sc->ready_list, ecb, chain);
1144 ecb->flags &= ~ECB_READY;
1145 sc->sc_nexus = ecb;
1146 ncr53c9x_select(sc, ecb);
1147 break;
1148 }
1149 if (li->untagged == NULL && tag != 0) {
1150 TAILQ_REMOVE(&sc->ready_list, ecb, chain);
1151 ecb->flags &= ~ECB_READY;
1152 sc->sc_nexus = ecb;
1153 ncr53c9x_select(sc, ecb);
1154 break;
1155 } else
1156 NCR_TRACE(("%d:%d busy\n",
1157 ecb->ccb->ccb_h.target_id,
1158 ecb->ccb->ccb_h.target_lun));
1159 }
1160}
1161
1162static void
1163ncr53c9x_sense(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
1164{
1165 union ccb *ccb = ecb->ccb;
1166 struct ncr53c9x_tinfo *ti;
1167 struct scsi_request_sense *ss = (void *)&ecb->cmd.cmd;
1168 struct ncr53c9x_linfo *li;
1169 int lun;
1170
1171 NCR_TRACE(("requesting sense "));
1172
1173 lun = ccb->ccb_h.target_lun;
1174 ti = &sc->sc_tinfo[ccb->ccb_h.target_id];
1175
1176 /* Next, setup a request sense command block */
1177 memset(ss, 0, sizeof(*ss));
1178 ss->opcode = REQUEST_SENSE;
1179 ss->byte2 = ccb->ccb_h.target_lun << SCSI_CMD_LUN_SHIFT;
1180 ss->length = sizeof(struct scsi_sense_data);
1181 ecb->clen = sizeof(*ss);
1182 ecb->daddr = (char *)&ecb->ccb->csio.sense_data;
1183 ecb->dleft = sizeof(struct scsi_sense_data);
1184 ecb->flags |= ECB_SENSE;
1185 ecb->timeout = NCR_SENSE_TIMEOUT;
1186 ti->senses++;
1187 li = TINFO_LUN(ti, lun);
1188 if (li->busy)
1189 li->busy = 0;
1190 ncr53c9x_dequeue(sc, ecb);
1191 li->untagged = ecb; /* must be executed first to fix C/A */
1192 li->busy = 2;
1193 if (ecb == sc->sc_nexus) {
1194 ncr53c9x_select(sc, ecb);
1195 } else {
1196 TAILQ_INSERT_HEAD(&sc->ready_list, ecb, chain);
1197 ecb->flags |= ECB_READY;
1198 if (sc->sc_state == NCR_IDLE)
1199 ncr53c9x_sched(sc);
1200 }
1201}
1202
1203/*
1204 * POST PROCESSING OF SCSI_CMD (usually current)
1205 */
1206static void
1207ncr53c9x_done(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
1208{
1209 union ccb *ccb = ecb->ccb;
1210 struct ncr53c9x_tinfo *ti;
1211 struct ncr53c9x_linfo *li;
1212 int lun;
1213
1214 NCR_TRACE(("[ncr53c9x_done(status:%x)] ", ccb->ccb_h.status));
1215
1216 ti = &sc->sc_tinfo[ccb->ccb_h.target_id];
1217 lun = ccb->ccb_h.target_lun;
1218 li = TINFO_LUN(ti, lun);
1219
1220 untimeout(ncr53c9x_timeout, ecb, ccb->ccb_h.timeout_ch);
1221
1222 /*
1223 * Now, if we've come here with no error code, i.e. we've kept the
1224 * initial XS_NOERROR, and the status code signals that we should
1225 * check sense, we'll need to set up a request sense cmd block and
1226 * push the command back into the ready queue *before* any other
1227 * commands for this target/lunit, else we lose the sense info.
1228 * We don't support chk sense conditions for the request sense cmd.
1229 */
1230 if (ccb->ccb_h.status == CAM_REQ_CMP) {
1231 if ((ecb->flags & ECB_ABORT) != 0) {
1232 ccb->ccb_h.status = CAM_CMD_TIMEOUT;
1233 } else if ((ecb->flags & ECB_SENSE) != 0 &&
1234 (ecb->stat != SCSI_STATUS_CHECK_COND)) {
1235 ccb->ccb_h.status = CAM_AUTOSNS_VALID;
1236 } else if (ecb->stat == SCSI_STATUS_CHECK_COND) {
1237 if ((ecb->flags & ECB_SENSE) != 0)
1238 ccb->ccb_h.status = CAM_AUTOSENSE_FAIL;
1239 else {
1240 /* First, save the return values */
1241 ccb->csio.resid = ecb->dleft;
1242 ncr53c9x_sense(sc, ecb);
1243 return;
1244 }
1245 } else {
1246 ccb->csio.resid = ecb->dleft;
1247 }
1248#if 0
1249 if (xs->status == SCSI_QUEUE_FULL || xs->status == XS_BUSY)
1250 xs->error = XS_BUSY;
1251#endif
1252 }
1253
1254#ifdef NCR53C9X_DEBUG
1255 if (ncr53c9x_debug & NCR_SHOWTRAC) {
1256 if (ccb->csio.resid != 0)
1257 printf("resid=%d ", ccb->csio.resid);
1258#if 0
1259 if (xs->error == XS_SENSE)
1260 printf("sense=0x%02x\n",
1261 xs->sense.scsi_sense.error_code);
1262 else
1263 printf("error=%d\n", xs->error);
1264#endif
1265 }
1266#endif
1267
1268 /*
1269 * Remove the ECB from whatever queue it's on.
1270 */
1271 ncr53c9x_dequeue(sc, ecb);
1272 if (ecb == sc->sc_nexus) {
1273 sc->sc_nexus = NULL;
1274 if (sc->sc_state != NCR_CLEANING) {
1275 sc->sc_state = NCR_IDLE;
1276 ncr53c9x_sched(sc);
1277 }
1278 }
1279
1280 if (ccb->ccb_h.status == CAM_SEL_TIMEOUT) {
1281 /* Selection timeout -- discard this LUN if empty */
1282 if (li->untagged == NULL && li->used == 0) {
1283 if (lun < NCR_NLUN)
1284 ti->lun[lun] = NULL;
1285 LIST_REMOVE(li, link);
1286 free(li, M_DEVBUF);
1287 }
1288 }
1289
1290 ncr53c9x_free_ecb(sc, ecb);
1291 ti->cmds++;
1292 xpt_done(ccb);
1293}
1294
1295static void
1296ncr53c9x_dequeue(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
1297{
1298 struct ncr53c9x_tinfo *ti;
1299 struct ncr53c9x_linfo *li;
1300 int64_t lun;
1301
1302 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
1303 lun = ecb->ccb->ccb_h.target_lun;
1304 li = TINFO_LUN(ti, lun);
1305#ifdef DIAGNOSTIC
1306 if (li == NULL || li->lun != lun)
1307 panic("ncr53c9x_dequeue: lun %qx for ecb %p does not exist",
1308 (long long) lun, ecb);
1309#endif
1310 if (li->untagged == ecb) {
1311 li->busy = 0;
1312 li->untagged = NULL;
1313 }
1314 if (ecb->tag[0] && li->queued[ecb->tag[1]] != NULL) {
1315#ifdef DIAGNOSTIC
1316 if (li->queued[ecb->tag[1]] != NULL &&
1317 (li->queued[ecb->tag[1]] != ecb))
1318 panic("ncr53c9x_dequeue: slot %d for lun %qx has %p "
1319 "instead of ecb %p\n", ecb->tag[1],
1320 (long long) lun,
1321 li->queued[ecb->tag[1]], ecb);
1322#endif
1323 li->queued[ecb->tag[1]] = NULL;
1324 li->used--;
1325 }
1326
1327 if ((ecb->flags & ECB_READY) != 0) {
1328 ecb->flags &= ~ECB_READY;
1329 TAILQ_REMOVE(&sc->ready_list, ecb, chain);
1330 }
1331}
1332
1333/*
1334 * INTERRUPT/PROTOCOL ENGINE
1335 */
1336
1337/*
1338 * Schedule an outgoing message by prioritizing it, and asserting
1339 * attention on the bus. We can only do this when we are the initiator
1340 * else there will be an illegal command interrupt.
1341 */
1342#define ncr53c9x_sched_msgout(m) \
1343 do { \
1344 NCR_MSGS(("ncr53c9x_sched_msgout %x %d", m, __LINE__)); \
1345 NCRCMD(sc, NCRCMD_SETATN); \
1346 sc->sc_flags |= NCR_ATN; \
1347 sc->sc_msgpriq |= (m); \
1348 } while (0)
1349
1350static void
1351ncr53c9x_flushfifo(struct ncr53c9x_softc *sc)
1352{
1353 NCR_TRACE(("[flushfifo] "));
1354
1355 NCRCMD(sc, NCRCMD_FLUSH);
1356
1357 if (sc->sc_phase == COMMAND_PHASE ||
1358 sc->sc_phase == MESSAGE_OUT_PHASE)
1359 DELAY(2);
1360}
1361
1362static int
1363ncr53c9x_rdfifo(struct ncr53c9x_softc *sc, int how)
1364{
1365 int i, n;
1366 u_char *buf;
1367
1368 switch(how) {
1369 case NCR_RDFIFO_START:
1370 buf = sc->sc_imess;
1371 sc->sc_imlen = 0;
1372 break;
1373 case NCR_RDFIFO_CONTINUE:
1374 buf = sc->sc_imess + sc->sc_imlen;
1375 break;
1376 default:
1377 panic("ncr53c9x_rdfifo: bad flag");
1378 break;
1379 }
1380
1381 /*
1382 * XXX buffer (sc_imess) size for message
1383 */
1384
1385 n = NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF;
1386
1387 if (sc->sc_rev == NCR_VARIANT_FAS366) {
1388 n *= 2;
1389
1390 for (i = 0; i < n; i++)
1391 buf[i] = NCR_READ_REG(sc, NCR_FIFO);
1392
1393 if (sc->sc_espstat2 & NCRFAS_STAT2_ISHUTTLE) {
1394
1395 NCR_WRITE_REG(sc, NCR_FIFO, 0);
1396 buf[i++] = NCR_READ_REG(sc, NCR_FIFO);
1397
1398 NCR_READ_REG(sc, NCR_FIFO);
1399
1400 ncr53c9x_flushfifo(sc);
1401 }
1402 } else {
1403 for (i = 0; i < n; i++)
1404 buf[i] = NCR_READ_REG(sc, NCR_FIFO);
1405 }
1406
1407 sc->sc_imlen += i;
1408
1409#if 0
1410#ifdef NCR53C9X_DEBUG
1411 {
1412 int j;
1413
1414 NCR_TRACE(("\n[rdfifo %s (%d):",
1415 (how == NCR_RDFIFO_START) ? "start" : "cont",
1416 (int)sc->sc_imlen));
1417 if (ncr53c9x_debug & NCR_SHOWTRAC) {
1418 for (j = 0; j < sc->sc_imlen; j++)
1419 printf(" %02x", sc->sc_imess[j]);
1420 printf("]\n");
1421 }
1422 }
1423#endif
1424#endif
1425 return sc->sc_imlen;
1426}
1427
1428static void
1429ncr53c9x_wrfifo(struct ncr53c9x_softc *sc, u_char *p, int len)
1430{
1431 int i;
1432
1433#ifdef NCR53C9X_DEBUG
1434 NCR_MSGS(("[wrfifo(%d):", len));
1435 if (ncr53c9x_debug & NCR_SHOWMSGS) {
1436 for (i = 0; i < len; i++)
1437 printf(" %02x", p[i]);
1438 printf("]\n");
1439 }
1440#endif
1441
1442 for (i = 0; i < len; i++) {
1443 NCR_WRITE_REG(sc, NCR_FIFO, p[i]);
1444
1445 if (sc->sc_rev == NCR_VARIANT_FAS366)
1446 NCR_WRITE_REG(sc, NCR_FIFO, 0);
1447 }
1448}
1449
1450static int
1451ncr53c9x_reselect(struct ncr53c9x_softc *sc, int message, int tagtype,
1452 int tagid)
1453{
1454 u_char selid, target, lun;
1455 struct ncr53c9x_ecb *ecb = NULL;
1456 struct ncr53c9x_tinfo *ti;
1457 struct ncr53c9x_linfo *li;
1458
1459
1460 if (sc->sc_rev == NCR_VARIANT_FAS366) {
1461 target = sc->sc_selid;
1462 } else {
1463 /*
1464 * The SCSI chip made a snapshot of the data bus
1465 * while the reselection was being negotiated.
1466 * This enables us to determine which target did
1467 * the reselect.
1468 */
1469 selid = sc->sc_selid & ~(1 << sc->sc_id);
1470 if (selid & (selid - 1)) {
1471 device_printf(sc->sc_dev, "reselect with invalid "
1472 "selid %02x; sending DEVICE RESET\n", selid);
1473 goto reset;
1474 }
1475
1476 target = ffs(selid) - 1;
1477 }
1478 lun = message & 0x07;
1479
1480 /*
1481 * Search wait queue for disconnected cmd
1482 * The list should be short, so I haven't bothered with
1483 * any more sophisticated structures than a simple
1484 * singly linked list.
1485 */
1486 ti = &sc->sc_tinfo[target];
1487 li = TINFO_LUN(ti, lun);
1488
1489 /*
1490 * We can get as far as the LUN with the IDENTIFY
1491 * message. Check to see if we're running an
1492 * un-tagged command. Otherwise ack the IDENTIFY
1493 * and wait for a tag message.
1494 */
1495 if (li != NULL) {
1496 if (li->untagged != NULL && li->busy)
1497 ecb = li->untagged;
1498 else if (tagtype != MSG_SIMPLE_Q_TAG) {
1499 /* Wait for tag to come by */
1500 sc->sc_state = NCR_IDENTIFIED;
1501 return (0);
1502 } else if (tagtype)
1503 ecb = li->queued[tagid];
1504 }
1505 if (ecb == NULL) {
1506 device_printf(sc->sc_dev, "reselect from target %d lun %d "
1507 "tag %x:%x with no nexus; sending ABORT\n",
1508 target, lun, tagtype, tagid);
1509 goto abort;
1510 }
1511
1512 /* Make this nexus active again. */
1513 sc->sc_state = NCR_CONNECTED;
1514 sc->sc_nexus = ecb;
1515 ncr53c9x_setsync(sc, ti);
1516
1517 if (ecb->flags & ECB_RESET)
1518 ncr53c9x_sched_msgout(SEND_DEV_RESET);
1519 else if (ecb->flags & ECB_ABORT)
1520 ncr53c9x_sched_msgout(SEND_ABORT);
1521
1522 /* Do an implicit RESTORE POINTERS. */
1523 sc->sc_dp = ecb->daddr;
1524 sc->sc_dleft = ecb->dleft;
1525
1526 return (0);
1527
1528reset:
1529 ncr53c9x_sched_msgout(SEND_DEV_RESET);
1530 return (1);
1531
1532abort:
1533 ncr53c9x_sched_msgout(SEND_ABORT);
1534 return (1);
1535}
1536
1537/* From NetBSD. These should go into CAM at some point */
1538#define MSG_ISEXTENDED(m) ((m) == MSG_EXTENDED)
1539#define MSG_IS1BYTE(m) \
1540 ((!MSG_ISEXTENDED(m) && (m) < 0x20) || MSG_ISIDENTIFY(m))
1541#define MSG_IS2BYTE(m) (((m) & 0xf0) == 0x20)
1542
1543static inline int
1544__verify_msg_format(u_char *p, int len)
1545{
1546
1547 if (len == 1 && MSG_IS1BYTE(p[0]))
1548 return 1;
1549 if (len == 2 && MSG_IS2BYTE(p[0]))
1550 return 1;
1551 if (len >= 3 && MSG_ISEXTENDED(p[0]) &&
1552 len == p[1] + 2)
1553 return 1;
1554
1555 return 0;
1556}
1557
1558/*
1559 * Get an incoming message as initiator.
1560 *
1561 * The SCSI bus must already be in MESSAGE_IN_PHASE and there is a
1562 * byte in the FIFO
1563 */
1564static void
1565ncr53c9x_msgin(struct ncr53c9x_softc *sc)
1566{
1567
1568 NCR_TRACE(("[ncr53c9x_msgin(curmsglen:%ld)] ", (long)sc->sc_imlen));
1569
1570 if (sc->sc_imlen == 0) {
1571 device_printf(sc->sc_dev, "msgin: no msg byte available\n");
1572 return;
1573 }
1574
1575 /*
1576 * Prepare for a new message. A message should (according
1577 * to the SCSI standard) be transmitted in one single
1578 * MESSAGE_IN_PHASE. If we have been in some other phase,
1579 * then this is a new message.
1580 */
1581 if (sc->sc_prevphase != MESSAGE_IN_PHASE &&
1582 sc->sc_state != NCR_RESELECTED) {
1583 device_printf(sc->sc_dev, "phase change, dropping message, "
1584 "prev %d, state %d\n", sc->sc_prevphase, sc->sc_state);
1585 sc->sc_flags &= ~NCR_DROP_MSGI;
1586 sc->sc_imlen = 0;
1587 }
1588
1589 /*
1590 * If we're going to reject the message, don't bother storing
1591 * the incoming bytes. But still, we need to ACK them.
1592 */
1593 if ((sc->sc_flags & NCR_DROP_MSGI) != 0) {
1594 NCRCMD(sc, NCRCMD_MSGOK);
1595 printf("<dropping msg byte %x>", sc->sc_imess[sc->sc_imlen]);
1596 return;
1597 }
1598
1599 if (sc->sc_imlen >= NCR_MAX_MSG_LEN) {
1600 ncr53c9x_sched_msgout(SEND_REJECT);
1601 sc->sc_flags |= NCR_DROP_MSGI;
1602 } else {
1603 u_char *pb;
1604 int plen;
1605
1606 switch (sc->sc_state) {
1607 /*
1608 * if received message is the first of reselection
1609 * then first byte is selid, and then message
1610 */
1611 case NCR_RESELECTED:
1612 pb = sc->sc_imess + 1;
1613 plen = sc->sc_imlen - 1;
1614 break;
1615 default:
1616 pb = sc->sc_imess;
1617 plen = sc->sc_imlen;
1618 break;
1619 }
1620
1621 if (__verify_msg_format(pb, plen))
1622 goto gotit;
1623 }
1624
1625 /* Ack what we have so far */
1626 NCRCMD(sc, NCRCMD_MSGOK);
1627 return;
1628
1629gotit:
1630 NCR_MSGS(("gotmsg(%x) state %d", sc->sc_imess[0], sc->sc_state));
1631 /* We got a complete message, flush the imess, */
1632 /* XXX nobody uses imlen below */
1633 sc->sc_imlen = 0;
1634 /*
1635 * Now we should have a complete message (1 byte, 2 byte
1636 * and moderately long extended messages). We only handle
1637 * extended messages which total length is shorter than
1638 * NCR_MAX_MSG_LEN. Longer messages will be amputated.
1639 */
1640 switch (sc->sc_state) {
1641 struct ncr53c9x_ecb *ecb;
1642 struct ncr53c9x_tinfo *ti;
1643 struct ncr53c9x_linfo *li;
1644 int lun;
1645
1646 case NCR_CONNECTED:
1647 ecb = sc->sc_nexus;
1648 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
1649
1650 switch (sc->sc_imess[0]) {
1651 case MSG_CMDCOMPLETE:
1652 NCR_MSGS(("cmdcomplete "));
1653 if (sc->sc_dleft < 0) {
1654 xpt_print_path(ecb->ccb->ccb_h.path);
1655 printf("got %ld extra bytes\n",
1656 -(long)sc->sc_dleft);
1657 sc->sc_dleft = 0;
1658 }
1659 ecb->dleft = (ecb->flags & ECB_TENTATIVE_DONE) ?
1660 0 : sc->sc_dleft;
1661 if ((ecb->flags & ECB_SENSE) == 0)
1662 ecb->ccb->csio.resid = ecb->dleft;
1663 sc->sc_state = NCR_CMDCOMPLETE;
1664 break;
1665
1666 case MSG_MESSAGE_REJECT:
1667 NCR_MSGS(("msg reject (msgout=%x) ", sc->sc_msgout));
1668 switch (sc->sc_msgout) {
1669 case SEND_TAG:
1670 /*
1671 * Target does not like tagged queuing.
1672 * - Flush the command queue
1673 * - Disable tagged queuing for the target
1674 * - Dequeue ecb from the queued array.
1675 */
1676 device_printf(sc->sc_dev, "tagged queuing "
1677 "rejected: target %d\n",
1678 ecb->ccb->ccb_h.target_id);
1679
1680 NCR_MSGS(("(rejected sent tag)"));
1681 NCRCMD(sc, NCRCMD_FLUSH);
1682 DELAY(1);
1683 ti->flags &= ~T_TAG;
1684 lun = ecb->ccb->ccb_h.target_lun;
1685 li = TINFO_LUN(ti, lun);
1686 if (ecb->tag[0] &&
1687 li->queued[ecb->tag[1]] != NULL) {
1688 li->queued[ecb->tag[1]] = NULL;
1689 li->used--;
1690 }
1691 ecb->tag[0] = ecb->tag[1] = 0;
1692 li->untagged = ecb;
1693 li->busy = 1;
1694 break;
1695
1696 case SEND_SDTR:
1697 device_printf(sc->sc_dev, "sync transfer "
1698 "rejected: target %d\n",
1699 ecb->ccb->ccb_h.target_id);
1700
1701 sc->sc_flags &= ~NCR_SYNCHNEGO;
1702 ti->flags &= ~(T_NEGOTIATE | T_SYNCMODE);
1703 ncr53c9x_setsync(sc, ti);
1704 break;
1705
1706 case SEND_WDTR:
1707 device_printf(sc->sc_dev, "wide transfer "
1708 "rejected: target %d\n",
1709 ecb->ccb->ccb_h.target_id);
1710 ti->flags &= ~(T_WIDE | T_WDTRSENT);
1711 ti->width = 0;
1712 break;
1713
1714 case SEND_INIT_DET_ERR:
1715 goto abort;
1716 }
1717 break;
1718
1719 case MSG_NOOP:
1720 NCR_MSGS(("noop "));
1721 break;
1722
1723 case MSG_HEAD_OF_Q_TAG:
1724 case MSG_SIMPLE_Q_TAG:
1725 case MSG_ORDERED_Q_TAG:
1726 NCR_MSGS(("TAG %x:%x",
1727 sc->sc_imess[0], sc->sc_imess[1]));
1728 break;
1729
1730 case MSG_DISCONNECT:
1731 NCR_MSGS(("disconnect "));
1732 ti->dconns++;
1733 sc->sc_state = NCR_DISCONNECT;
1734
1735 /*
1736 * Mark the fact that all bytes have moved. The
1737 * target may not bother to do a SAVE POINTERS
1738 * at this stage. This flag will set the residual
1739 * count to zero on MSG COMPLETE.
1740 */
1741 if (sc->sc_dleft == 0)
1742 ecb->flags |= ECB_TENTATIVE_DONE;
1743
1744 break;
1745
1746 case MSG_SAVEDATAPOINTER:
1747 NCR_MSGS(("save datapointer "));
1748 ecb->daddr = sc->sc_dp;
1749 ecb->dleft = sc->sc_dleft;
1750 break;
1751
1752 case MSG_RESTOREPOINTERS:
1753 NCR_MSGS(("restore datapointer "));
1754 sc->sc_dp = ecb->daddr;
1755 sc->sc_dleft = ecb->dleft;
1756 break;
1757
1758 case MSG_EXTENDED:
1759 NCR_MSGS(("extended(%x) ", sc->sc_imess[2]));
1760 switch (sc->sc_imess[2]) {
1761 case MSG_EXT_SDTR:
1762 NCR_MSGS(("SDTR period %d, offset %d ",
1763 sc->sc_imess[3], sc->sc_imess[4]));
1764 if (sc->sc_imess[1] != 3)
1765 goto reject;
1766 ti->period = sc->sc_imess[3];
1767 ti->offset = sc->sc_imess[4];
1768 ti->flags &= ~T_NEGOTIATE;
1769 if (sc->sc_minsync == 0 ||
1770 ti->offset == 0 ||
1771 ti->period > 124) {
1772#if 0
1773#ifdef NCR53C9X_DEBUG
1774 xpt_print_path(ecb->ccb->ccb_h.path);
1775 printf("async mode\n");
1776#endif
1777#endif
1778 ti->flags &= ~T_SYNCMODE;
1779 if ((sc->sc_flags&NCR_SYNCHNEGO) == 0) {
1780 /*
1781 * target initiated negotiation
1782 */
1783 ti->offset = 0;
1784 ncr53c9x_sched_msgout(
1785 SEND_SDTR);
1786 }
1787 } else {
1788 int p;
1789
1790 p = ncr53c9x_stp2cpb(sc, ti->period);
1791 ti->period = ncr53c9x_cpb2stp(sc, p);
1792 if ((sc->sc_flags&NCR_SYNCHNEGO) == 0) {
1793 /*
1794 * target initiated negotiation
1795 */
| 578 for (r = 0; r < sc->sc_ntarg; r++) {
579 struct ncr53c9x_tinfo *ti = &sc->sc_tinfo[r];
580/* XXX - config flags per target: low bits: no reselect; high bits: no synch */
581
582 ti->flags = ((sc->sc_minsync && !(sc->sc_cfflags & (1<<((r&7)+8))))
583 ? 0 : T_SYNCHOFF) |
584 ((sc->sc_cfflags & (1<<(r&7))) ? T_RSELECTOFF : 0);
585#ifdef DEBUG
586 if (ncr53c9x_notag)
587 ti->flags &= ~T_TAG;
588#endif
589 ti->period = sc->sc_minsync;
590 ti->offset = 0;
591 ti->cfg3 = 0;
592 }
593
594 if (doreset) {
595 sc->sc_state = NCR_SBR;
596 NCRCMD(sc, NCRCMD_RSTSCSI);
597 } else {
598 sc->sc_state = NCR_IDLE;
599 ncr53c9x_sched(sc);
600 }
601}
602
603/*
604 * Read the NCR registers, and save their contents for later use.
605 * NCR_STAT, NCR_STEP & NCR_INTR are mostly zeroed out when reading
606 * NCR_INTR - so make sure it is the last read.
607 *
608 * I think that (from reading the docs) most bits in these registers
609 * only make sense when he DMA CSR has an interrupt showing. Call only
610 * if an interrupt is pending.
611 */
612static __inline void
613ncr53c9x_readregs(struct ncr53c9x_softc *sc)
614{
615
616 sc->sc_espstat = NCR_READ_REG(sc, NCR_STAT);
617 /* Only the stepo bits are of interest */
618 sc->sc_espstep = NCR_READ_REG(sc, NCR_STEP) & NCRSTEP_MASK;
619
620 if (sc->sc_rev == NCR_VARIANT_FAS366)
621 sc->sc_espstat2 = NCR_READ_REG(sc, NCR_STAT2);
622
623 sc->sc_espintr = NCR_READ_REG(sc, NCR_INTR);
624
625 if (sc->sc_glue->gl_clear_latched_intr != NULL)
626 (*sc->sc_glue->gl_clear_latched_intr)(sc);
627
628 /*
629 * Determine the SCSI bus phase, return either a real SCSI bus phase
630 * or some pseudo phase we use to detect certain exceptions.
631 */
632
633 sc->sc_phase = (sc->sc_espintr & NCRINTR_DIS) ?
634 /* Disconnected */ BUSFREE_PHASE : sc->sc_espstat & NCRSTAT_PHASE;
635
636 NCR_INTS(("regs[intr=%02x,stat=%02x,step=%02x,stat2=%02x] ",
637 sc->sc_espintr, sc->sc_espstat, sc->sc_espstep, sc->sc_espstat2));
638}
639
640/*
641 * Convert Synchronous Transfer Period to chip register Clock Per Byte value.
642 */
643static __inline int
644ncr53c9x_stp2cpb(struct ncr53c9x_softc *sc, int period)
645{
646 int v;
647 v = (sc->sc_freq * period) / 250;
648 if (ncr53c9x_cpb2stp(sc, v) < period)
649 /* Correct round-down error */
650 v++;
651 return (v);
652}
653
654static __inline void
655ncr53c9x_setsync(struct ncr53c9x_softc *sc, struct ncr53c9x_tinfo *ti)
656{
657 u_char syncoff, synctp;
658 u_char cfg3 = sc->sc_cfg3 | ti->cfg3;
659
660 if (ti->flags & T_SYNCMODE) {
661 syncoff = ti->offset;
662 synctp = ncr53c9x_stp2cpb(sc, ti->period);
663 if (sc->sc_features & NCR_F_FASTSCSI) {
664 /*
665 * If the period is 200ns or less (ti->period <= 50),
666 * put the chip in Fast SCSI mode.
667 */
668 if (ti->period <= 50)
669 /*
670 * There are (at least) 4 variations of the
671 * configuration 3 register. The drive attach
672 * routine sets the appropriate bit to put the
673 * chip into Fast SCSI mode so that it doesn't
674 * have to be figured out here each time.
675 */
676 cfg3 |= sc->sc_cfg3_fscsi;
677 }
678
679 /*
680 * Am53c974 requires different SYNCTP values when the
681 * FSCSI bit is off.
682 */
683 if (sc->sc_rev == NCR_VARIANT_AM53C974 &&
684 (cfg3 & NCRAMDCFG3_FSCSI) == 0)
685 synctp--;
686 } else {
687 syncoff = 0;
688 synctp = 0;
689 }
690
691 if (sc->sc_features & NCR_F_HASCFG3)
692 NCR_WRITE_REG(sc, NCR_CFG3, cfg3);
693
694 NCR_WRITE_REG(sc, NCR_SYNCOFF, syncoff);
695 NCR_WRITE_REG(sc, NCR_SYNCTP, synctp);
696}
697
698/*
699 * Send a command to a target, set the driver state to NCR_SELECTING
700 * and let the caller take care of the rest.
701 *
702 * Keeping this as a function allows me to say that this may be done
703 * by DMA instead of programmed I/O soon.
704 */
705static void
706ncr53c9x_select(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
707{
708 int target = ecb->ccb->ccb_h.target_id;
709 int lun = ecb->ccb->ccb_h.target_lun;
710 struct ncr53c9x_tinfo *ti;
711 int tiflags;
712 u_char *cmd;
713 int clen;
714 int selatn3, selatns;
715 size_t dmasize;
716
717 NCR_TRACE(("[ncr53c9x_select(t%d,l%d,cmd:%x,tag:%x,%x)] ",
718 target, lun, ecb->cmd.cmd.opcode, ecb->tag[0], ecb->tag[1]));
719
720 ti = &sc->sc_tinfo[target];
721 tiflags = ti->flags;
722 sc->sc_state = NCR_SELECTING;
723 /*
724 * Schedule the timeout now, the first time we will go away
725 * expecting to come back due to an interrupt, because it is
726 * always possible that the interrupt may never happen.
727 */
728 ecb->ccb->ccb_h.timeout_ch =
729 timeout(ncr53c9x_timeout, ecb, mstohz(ecb->timeout));
730
731 /*
732 * The docs say the target register is never reset, and I
733 * can't think of a better place to set it
734 */
735 if (sc->sc_rev == NCR_VARIANT_FAS366) {
736 NCRCMD(sc, NCRCMD_FLUSH);
737 NCR_WRITE_REG(sc, NCR_SELID, target | NCR_BUSID_HME);
738 } else {
739 NCR_WRITE_REG(sc, NCR_SELID, target);
740 }
741 ncr53c9x_setsync(sc, ti);
742
743 if ((ecb->flags & ECB_SENSE) != 0) {
744 /*
745 * For REQUEST SENSE, we should not send an IDENTIFY or
746 * otherwise mangle the target. There should be no MESSAGE IN
747 * phase.
748 */
749 if (sc->sc_features & NCR_F_DMASELECT) {
750 /* setup DMA transfer for command */
751 dmasize = clen = ecb->clen;
752 sc->sc_cmdlen = clen;
753 sc->sc_cmdp = (caddr_t)&ecb->cmd.cmd;
754
755 /* Program the SCSI counter */
756 NCR_SET_COUNT(sc, dmasize);
757
758 if (sc->sc_rev != NCR_VARIANT_FAS366)
759 NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
760
761 /* And get the targets attention */
762 NCRCMD(sc, NCRCMD_SELNATN | NCRCMD_DMA);
763 NCRDMA_SETUP(sc, &sc->sc_cmdp, &sc->sc_cmdlen, 0,
764 &dmasize);
765 NCRDMA_GO(sc);
766 } else {
767 ncr53c9x_wrfifo(sc, (u_char *)&ecb->cmd.cmd, ecb->clen);
768 NCRCMD(sc, NCRCMD_SELNATN);
769 }
770 return;
771 }
772
773 selatn3 = selatns = 0;
774 if (ecb->tag[0] != 0) {
775 if (sc->sc_features & NCR_F_SELATN3)
776 /* use SELATN3 to send tag messages */
777 selatn3 = 1;
778 else
779 /* We don't have SELATN3; use SELATNS to send tags */
780 selatns = 1;
781 }
782
783 if (ti->flags & T_NEGOTIATE) {
784 /* We have to use SELATNS to send sync/wide messages */
785 selatn3 = 0;
786 selatns = 1;
787 }
788
789 cmd = (u_char *)&ecb->cmd.cmd;
790
791 if (selatn3) {
792 /* We'll use tags with SELATN3 */
793 clen = ecb->clen + 3;
794 cmd -= 3;
795 cmd[0] = MSG_IDENTIFY(lun, 1); /* msg[0] */
796 cmd[1] = ecb->tag[0]; /* msg[1] */
797 cmd[2] = ecb->tag[1]; /* msg[2] */
798 } else {
799 /* We don't have tags, or will send messages with SELATNS */
800 clen = ecb->clen + 1;
801 cmd -= 1;
802 cmd[0] = MSG_IDENTIFY(lun, (tiflags & T_RSELECTOFF) == 0);
803 }
804
805 if ((sc->sc_features & NCR_F_DMASELECT) && !selatns) {
806
807 /* setup DMA transfer for command */
808 dmasize = clen;
809 sc->sc_cmdlen = clen;
810 sc->sc_cmdp = cmd;
811
812 /* Program the SCSI counter */
813 NCR_SET_COUNT(sc, dmasize);
814
815 /* load the count in */
816 /* if (sc->sc_rev != NCR_VARIANT_FAS366) */
817 NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
818
819 /* And get the targets attention */
820 if (selatn3) {
821 sc->sc_msgout = SEND_TAG;
822 sc->sc_flags |= NCR_ATN;
823 NCRCMD(sc, NCRCMD_SELATN3 | NCRCMD_DMA);
824 } else
825 NCRCMD(sc, NCRCMD_SELATN | NCRCMD_DMA);
826 NCRDMA_SETUP(sc, &sc->sc_cmdp, &sc->sc_cmdlen, 0, &dmasize);
827 NCRDMA_GO(sc);
828 return;
829 }
830
831 /*
832 * Who am I? This is where we tell the target that we are
833 * happy for it to disconnect etc.
834 */
835
836 /* Now get the command into the FIFO */
837 ncr53c9x_wrfifo(sc, cmd, clen);
838
839 /* And get the targets attention */
840 if (selatns) {
841 NCR_MSGS(("SELATNS \n"));
842 /* Arbitrate, select and stop after IDENTIFY message */
843 NCRCMD(sc, NCRCMD_SELATNS);
844 } else if (selatn3) {
845 sc->sc_msgout = SEND_TAG;
846 sc->sc_flags |= NCR_ATN;
847 NCRCMD(sc, NCRCMD_SELATN3);
848 } else
849 NCRCMD(sc, NCRCMD_SELATN);
850}
851
852static void
853ncr53c9x_free_ecb(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
854{
855
856 ecb->flags = 0;
857 TAILQ_INSERT_TAIL(&sc->free_list, ecb, free_links);
858 return;
859}
860
861static struct ncr53c9x_ecb *
862ncr53c9x_get_ecb(struct ncr53c9x_softc *sc)
863{
864 struct ncr53c9x_ecb *ecb;
865
866 ecb = TAILQ_FIRST(&sc->free_list);
867 if (ecb) {
868 if (ecb->flags != 0)
869 panic("ecb flags not cleared\n");
870 TAILQ_REMOVE(&sc->free_list, ecb, free_links);
871 ecb->flags = ECB_ALLOC;
872 bzero(&ecb->ccb, sizeof(struct ncr53c9x_ecb) -
873 offsetof(struct ncr53c9x_ecb, ccb));
874 }
875 return (ecb);
876}
877
878/*
879 * DRIVER FUNCTIONS CALLABLE FROM HIGHER LEVEL DRIVERS:
880 */
881
882/*
883 * Start a SCSI-command
884 * This function is called by the higher level SCSI-driver to queue/run
885 * SCSI-commands.
886 */
887
888void
889ncr53c9x_action(struct cam_sim *sim, union ccb *ccb)
890{
891 struct ncr53c9x_softc *sc;
892 struct ncr53c9x_ecb *ecb;
893
894 NCR_TRACE(("[ncr53c9x_action %d]", ccb->ccb_h.func_code));
895
896 sc = cam_sim_softc(sim);
897 mtx_lock(&sc->sc_lock);
898
899 switch (ccb->ccb_h.func_code) {
900 case XPT_RESET_BUS:
901 ncr53c9x_scsi_reset(sc);
902 ccb->ccb_h.status = CAM_REQ_CMP;
903 mtx_unlock(&sc->sc_lock);
904 xpt_done(ccb);
905 return;
906 case XPT_CALC_GEOMETRY:
907 mtx_unlock(&sc->sc_lock);
908 cam_calc_geometry(&ccb->ccg, sc->sc_extended_geom);
909 xpt_done(ccb);
910 return;
911 case XPT_PATH_INQ:
912 {
913 struct ccb_pathinq *cpi = &ccb->cpi;
914
915 cpi->version_num = 1;
916 cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE;
917 cpi->hba_inquiry |=
918 (sc->sc_rev == NCR_VARIANT_FAS366) ? PI_WIDE_16 : 0;
919 cpi->target_sprt = 0;
920 cpi->hba_misc = 0;
921 cpi->hba_eng_cnt = 0;
922 cpi->max_target = sc->sc_ntarg - 1;
923 cpi->max_lun = 8;
924 cpi->initiator_id = sc->sc_id;
925 cpi->bus_id = 0;
926 cpi->base_transfer_speed = 3300;
927 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
928 strncpy(cpi->hba_vid, "Sun", HBA_IDLEN);
929 strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
930 cpi->unit_number = cam_sim_unit(sim);
931 ccb->ccb_h.status = CAM_REQ_CMP;
932 mtx_unlock(&sc->sc_lock);
933 xpt_done(ccb);
934 return;
935 }
936 case XPT_GET_TRAN_SETTINGS:
937 {
938 struct ccb_trans_settings *cts = &ccb->cts;
939 struct ncr53c9x_tinfo *ti;
940
941 ti = &sc->sc_tinfo[ccb->ccb_h.target_id];
942
943 if ((cts->flags & CCB_TRANS_CURRENT_SETTINGS) != 0) {
944 cts->sync_period = ti->period;
945 cts->sync_offset = ti->offset;
946 cts->bus_width = ti->width;
947 if ((ti->flags & T_TAG) != 0)
948 cts->flags |=
949 (CCB_TRANS_DISC_ENB | CCB_TRANS_TAG_ENB);
950 else
951 cts->flags &=
952 ~(CCB_TRANS_DISC_ENB | CCB_TRANS_TAG_ENB);
953 } else {
954 cts->sync_period = sc->sc_maxsync;
955 cts->sync_offset = sc->sc_maxoffset;
956 cts->bus_width = sc->sc_maxwidth;
957 cts->flags |= (CCB_TRANS_DISC_ENB | CCB_TRANS_TAG_ENB);
958 }
959 cts->valid = CCB_TRANS_BUS_WIDTH_VALID |
960 CCB_TRANS_SYNC_RATE_VALID |
961 CCB_TRANS_SYNC_OFFSET_VALID |
962 CCB_TRANS_DISC_VALID |
963 CCB_TRANS_TQ_VALID;
964 ccb->ccb_h.status = CAM_REQ_CMP;
965 mtx_unlock(&sc->sc_lock);
966 xpt_done(ccb);
967 return;
968 }
969 case XPT_ABORT:
970 printf("XPT_ABORT called\n");
971 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
972 mtx_unlock(&sc->sc_lock);
973 xpt_done(ccb);
974 return;
975 case XPT_TERM_IO:
976 printf("XPT_TERM_IO called\n");
977 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
978 mtx_unlock(&sc->sc_lock);
979 xpt_done(ccb);
980 return;
981 case XPT_RESET_DEV:
982 printf("XPT_RESET_DEV called\n");
983 case XPT_SCSI_IO:
984 {
985 struct ccb_scsiio *csio;
986
987 if (ccb->ccb_h.target_id < 0 ||
988 ccb->ccb_h.target_id >= sc->sc_ntarg) {
989 ccb->ccb_h.status = CAM_PATH_INVALID;
990 mtx_unlock(&sc->sc_lock);
991 xpt_done(ccb);
992 return;
993 }
994 /* Get an ECB to use. */
995 ecb = ncr53c9x_get_ecb(sc);
996 /*
997 * This should never happen as we track resources
998 * in the mid-layer.
999 */
1000 if (ecb == NULL) {
1001 xpt_freeze_simq(sim, 1);
1002 ccb->ccb_h.status = CAM_REQUEUE_REQ;
1003 printf("unable to allocate ecb\n");
1004 mtx_unlock(&sc->sc_lock);
1005 xpt_done(ccb);
1006 return;
1007 }
1008
1009 /* Initialize ecb */
1010 ecb->ccb = ccb;
1011 ecb->timeout = ccb->ccb_h.timeout;
1012
1013 if (ccb->ccb_h.func_code == XPT_RESET_DEV) {
1014 ecb->flags |= ECB_RESET;
1015 ecb->clen = 0;
1016 ecb->dleft = 0;
1017 } else {
1018 csio = &ccb->csio;
1019 if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0)
1020 bcopy(csio->cdb_io.cdb_ptr, &ecb->cmd.cmd,
1021 csio->cdb_len);
1022 else
1023 bcopy(csio->cdb_io.cdb_bytes, &ecb->cmd.cmd,
1024 csio->cdb_len);
1025 ecb->clen = csio->cdb_len;
1026 ecb->daddr = csio->data_ptr;
1027 ecb->dleft = csio->dxfer_len;
1028 }
1029 ecb->stat = 0;
1030
1031 TAILQ_INSERT_TAIL(&sc->ready_list, ecb, chain);
1032 ecb->flags |= ECB_READY;
1033 if (sc->sc_state == NCR_IDLE)
1034 ncr53c9x_sched(sc);
1035
1036 break;
1037 }
1038
1039 case XPT_SET_TRAN_SETTINGS:
1040 {
1041 struct ncr53c9x_tinfo *ti;
1042 struct ccb_trans_settings *cts = &ccb->cts;
1043 int target = ccb->ccb_h.target_id;
1044
1045 ti = &sc->sc_tinfo[target];
1046
1047 if ((cts->valid & CCB_TRANS_TQ_VALID) != 0) {
1048 if ((sc->sc_cfflags & (1<<((target & 7) + 16))) == 0 &&
1049 (cts->flags & CCB_TRANS_TAG_ENB)) {
1050 NCR_MISC(("%s: target %d: tagged queuing\n",
1051 device_get_nameunit(sc->sc_dev), target));
1052 ti->flags |= T_TAG;
1053 } else
1054 ti->flags &= ~T_TAG;
1055 }
1056
1057 if ((cts->valid & CCB_TRANS_BUS_WIDTH_VALID) != 0) {
1058 if (cts->bus_width != 0) {
1059 NCR_MISC(("%s: target %d: wide negotiation\n",
1060 device_get_nameunit(sc->sc_dev), target));
1061 if (sc->sc_rev == NCR_VARIANT_FAS366) {
1062 ti->flags |= T_WIDE;
1063 ti->width = 1;
1064 }
1065 } else {
1066 ti->flags &= ~T_WIDE;
1067 ti->width = 0;
1068 }
1069 ti->flags |= T_NEGOTIATE;
1070 }
1071
1072 if ((cts->valid & CCB_TRANS_SYNC_RATE_VALID) != 0) {
1073 NCR_MISC(("%s: target %d: sync period negotiation\n",
1074 device_get_nameunit(sc->sc_dev), target));
1075 ti->flags |= T_NEGOTIATE;
1076 ti->period = cts->sync_period;
1077 }
1078
1079 if ((cts->valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0) {
1080 NCR_MISC(("%s: target %d: sync offset negotiation\n",
1081 device_get_nameunit(sc->sc_dev), target));
1082 ti->flags |= T_NEGOTIATE;
1083 ti->offset = cts->sync_offset;
1084 }
1085
1086 mtx_unlock(&sc->sc_lock);
1087 ccb->ccb_h.status = CAM_REQ_CMP;
1088 xpt_done(ccb);
1089 return;
1090 }
1091
1092 default:
1093 device_printf(sc->sc_dev, "Unhandled function code %d\n",
1094 ccb->ccb_h.func_code);
1095 ccb->ccb_h.status = CAM_PROVIDE_FAIL;
1096 mtx_unlock(&sc->sc_lock);
1097 xpt_done(ccb);
1098 return;
1099 }
1100
1101 mtx_unlock(&sc->sc_lock);
1102}
1103
1104/*
1105 * Used when interrupt driven I/O is not allowed, e.g. during boot.
1106 */
1107static void
1108ncr53c9x_poll(struct cam_sim *sim)
1109{
1110 struct ncr53c9x_softc *sc;
1111
1112 NCR_TRACE(("[ncr53c9x_poll] "));
1113 sc = cam_sim_softc(sim);
1114 if (NCRDMA_ISINTR(sc)) {
1115 ncr53c9x_intr(sc);
1116 }
1117}
1118
1119/*
1120 * LOW LEVEL SCSI UTILITIES
1121 */
1122
1123/*
1124 * Schedule a scsi operation. This has now been pulled out of the interrupt
1125 * handler so that we may call it from ncr53c9x_scsipi_request and
1126 * ncr53c9x_done. This may save us an unnecessary interrupt just to get
1127 * things going. Should only be called when state == NCR_IDLE and at bio pl.
1128 */
1129static void
1130ncr53c9x_sched(struct ncr53c9x_softc *sc)
1131{
1132 struct ncr53c9x_ecb *ecb;
1133 struct ncr53c9x_tinfo *ti;
1134 struct ncr53c9x_linfo *li;
1135 int lun;
1136 int tag;
1137
1138 NCR_TRACE(("[ncr53c9x_sched] "));
1139 if (sc->sc_state != NCR_IDLE)
1140 panic("ncr53c9x_sched: not IDLE (state=%d)", sc->sc_state);
1141
1142 /*
1143 * Find first ecb in ready queue that is for a target/lunit
1144 * combinations that is not busy.
1145 */
1146 for (ecb = TAILQ_FIRST(&sc->ready_list); ecb != NULL;
1147 ecb = TAILQ_NEXT(ecb, chain)) {
1148 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
1149 lun = ecb->ccb->ccb_h.target_lun;
1150
1151 /* Select type of tag for this command */
1152 if ((ti->flags & (T_RSELECTOFF)) != 0)
1153 tag = 0;
1154 else if ((ti->flags & (T_TAG)) == 0)
1155 tag = 0;
1156 else if ((ecb->flags & ECB_SENSE) != 0)
1157 tag = 0;
1158 else if ((ecb->ccb->ccb_h.flags & CAM_TAG_ACTION_VALID) == 0)
1159 tag = 0;
1160 else if (ecb->ccb->csio.tag_action == CAM_TAG_ACTION_NONE)
1161 tag = 0;
1162 else
1163 tag = ecb->ccb->csio.tag_action;
1164
1165 li = TINFO_LUN(ti, lun);
1166 if (li == NULL) {
1167 /* Initialize LUN info and add to list. */
1168 if ((li = malloc(sizeof(*li),
1169 M_DEVBUF, M_NOWAIT|M_ZERO)) == NULL) {
1170 continue;
1171 }
1172 li->lun = lun;
1173
1174 LIST_INSERT_HEAD(&ti->luns, li, link);
1175 if (lun < NCR_NLUN)
1176 ti->lun[lun] = li;
1177 }
1178 li->last_used = time_second;
1179 if (tag == 0) {
1180 /* Try to issue this as an un-tagged command */
1181 if (li->untagged == NULL)
1182 li->untagged = ecb;
1183 }
1184 if (li->untagged != NULL) {
1185 tag = 0;
1186 if ((li->busy != 1) && li->used == 0) {
1187 /* We need to issue this untagged command now */
1188 ecb = li->untagged;
1189 } else {
1190 /* Not ready yet */
1191 continue;
1192 }
1193 }
1194 ecb->tag[0] = tag;
1195 if (tag != 0) {
1196 li->queued[ecb->tag_id] = ecb;
1197 ecb->tag[1] = ecb->tag_id;
1198 li->used++;
1199 }
1200 if (li->untagged != NULL && (li->busy != 1)) {
1201 li->busy = 1;
1202 TAILQ_REMOVE(&sc->ready_list, ecb, chain);
1203 ecb->flags &= ~ECB_READY;
1204 sc->sc_nexus = ecb;
1205 ncr53c9x_select(sc, ecb);
1206 break;
1207 }
1208 if (li->untagged == NULL && tag != 0) {
1209 TAILQ_REMOVE(&sc->ready_list, ecb, chain);
1210 ecb->flags &= ~ECB_READY;
1211 sc->sc_nexus = ecb;
1212 ncr53c9x_select(sc, ecb);
1213 break;
1214 } else
1215 NCR_TRACE(("%d:%d busy\n",
1216 ecb->ccb->ccb_h.target_id,
1217 ecb->ccb->ccb_h.target_lun));
1218 }
1219}
1220
1221static void
1222ncr53c9x_sense(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
1223{
1224 union ccb *ccb = ecb->ccb;
1225 struct ncr53c9x_tinfo *ti;
1226 struct scsi_request_sense *ss = (void *)&ecb->cmd.cmd;
1227 struct ncr53c9x_linfo *li;
1228 int lun;
1229
1230 NCR_TRACE(("requesting sense "));
1231
1232 lun = ccb->ccb_h.target_lun;
1233 ti = &sc->sc_tinfo[ccb->ccb_h.target_id];
1234
1235 /* Next, setup a request sense command block */
1236 memset(ss, 0, sizeof(*ss));
1237 ss->opcode = REQUEST_SENSE;
1238 ss->byte2 = ccb->ccb_h.target_lun << SCSI_CMD_LUN_SHIFT;
1239 ss->length = sizeof(struct scsi_sense_data);
1240 ecb->clen = sizeof(*ss);
1241 ecb->daddr = (char *)&ecb->ccb->csio.sense_data;
1242 ecb->dleft = sizeof(struct scsi_sense_data);
1243 ecb->flags |= ECB_SENSE;
1244 ecb->timeout = NCR_SENSE_TIMEOUT;
1245 ti->senses++;
1246 li = TINFO_LUN(ti, lun);
1247 if (li->busy)
1248 li->busy = 0;
1249 ncr53c9x_dequeue(sc, ecb);
1250 li->untagged = ecb; /* must be executed first to fix C/A */
1251 li->busy = 2;
1252 if (ecb == sc->sc_nexus) {
1253 ncr53c9x_select(sc, ecb);
1254 } else {
1255 TAILQ_INSERT_HEAD(&sc->ready_list, ecb, chain);
1256 ecb->flags |= ECB_READY;
1257 if (sc->sc_state == NCR_IDLE)
1258 ncr53c9x_sched(sc);
1259 }
1260}
1261
1262/*
1263 * POST PROCESSING OF SCSI_CMD (usually current)
1264 */
1265static void
1266ncr53c9x_done(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
1267{
1268 union ccb *ccb = ecb->ccb;
1269 struct ncr53c9x_tinfo *ti;
1270 struct ncr53c9x_linfo *li;
1271 int lun;
1272
1273 NCR_TRACE(("[ncr53c9x_done(status:%x)] ", ccb->ccb_h.status));
1274
1275 ti = &sc->sc_tinfo[ccb->ccb_h.target_id];
1276 lun = ccb->ccb_h.target_lun;
1277 li = TINFO_LUN(ti, lun);
1278
1279 untimeout(ncr53c9x_timeout, ecb, ccb->ccb_h.timeout_ch);
1280
1281 /*
1282 * Now, if we've come here with no error code, i.e. we've kept the
1283 * initial XS_NOERROR, and the status code signals that we should
1284 * check sense, we'll need to set up a request sense cmd block and
1285 * push the command back into the ready queue *before* any other
1286 * commands for this target/lunit, else we lose the sense info.
1287 * We don't support chk sense conditions for the request sense cmd.
1288 */
1289 if (ccb->ccb_h.status == CAM_REQ_CMP) {
1290 if ((ecb->flags & ECB_ABORT) != 0) {
1291 ccb->ccb_h.status = CAM_CMD_TIMEOUT;
1292 } else if ((ecb->flags & ECB_SENSE) != 0 &&
1293 (ecb->stat != SCSI_STATUS_CHECK_COND)) {
1294 ccb->ccb_h.status = CAM_AUTOSNS_VALID;
1295 } else if (ecb->stat == SCSI_STATUS_CHECK_COND) {
1296 if ((ecb->flags & ECB_SENSE) != 0)
1297 ccb->ccb_h.status = CAM_AUTOSENSE_FAIL;
1298 else {
1299 /* First, save the return values */
1300 ccb->csio.resid = ecb->dleft;
1301 ncr53c9x_sense(sc, ecb);
1302 return;
1303 }
1304 } else {
1305 ccb->csio.resid = ecb->dleft;
1306 }
1307#if 0
1308 if (xs->status == SCSI_QUEUE_FULL || xs->status == XS_BUSY)
1309 xs->error = XS_BUSY;
1310#endif
1311 }
1312
1313#ifdef NCR53C9X_DEBUG
1314 if (ncr53c9x_debug & NCR_SHOWTRAC) {
1315 if (ccb->csio.resid != 0)
1316 printf("resid=%d ", ccb->csio.resid);
1317#if 0
1318 if (xs->error == XS_SENSE)
1319 printf("sense=0x%02x\n",
1320 xs->sense.scsi_sense.error_code);
1321 else
1322 printf("error=%d\n", xs->error);
1323#endif
1324 }
1325#endif
1326
1327 /*
1328 * Remove the ECB from whatever queue it's on.
1329 */
1330 ncr53c9x_dequeue(sc, ecb);
1331 if (ecb == sc->sc_nexus) {
1332 sc->sc_nexus = NULL;
1333 if (sc->sc_state != NCR_CLEANING) {
1334 sc->sc_state = NCR_IDLE;
1335 ncr53c9x_sched(sc);
1336 }
1337 }
1338
1339 if (ccb->ccb_h.status == CAM_SEL_TIMEOUT) {
1340 /* Selection timeout -- discard this LUN if empty */
1341 if (li->untagged == NULL && li->used == 0) {
1342 if (lun < NCR_NLUN)
1343 ti->lun[lun] = NULL;
1344 LIST_REMOVE(li, link);
1345 free(li, M_DEVBUF);
1346 }
1347 }
1348
1349 ncr53c9x_free_ecb(sc, ecb);
1350 ti->cmds++;
1351 xpt_done(ccb);
1352}
1353
1354static void
1355ncr53c9x_dequeue(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
1356{
1357 struct ncr53c9x_tinfo *ti;
1358 struct ncr53c9x_linfo *li;
1359 int64_t lun;
1360
1361 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
1362 lun = ecb->ccb->ccb_h.target_lun;
1363 li = TINFO_LUN(ti, lun);
1364#ifdef DIAGNOSTIC
1365 if (li == NULL || li->lun != lun)
1366 panic("ncr53c9x_dequeue: lun %qx for ecb %p does not exist",
1367 (long long) lun, ecb);
1368#endif
1369 if (li->untagged == ecb) {
1370 li->busy = 0;
1371 li->untagged = NULL;
1372 }
1373 if (ecb->tag[0] && li->queued[ecb->tag[1]] != NULL) {
1374#ifdef DIAGNOSTIC
1375 if (li->queued[ecb->tag[1]] != NULL &&
1376 (li->queued[ecb->tag[1]] != ecb))
1377 panic("ncr53c9x_dequeue: slot %d for lun %qx has %p "
1378 "instead of ecb %p\n", ecb->tag[1],
1379 (long long) lun,
1380 li->queued[ecb->tag[1]], ecb);
1381#endif
1382 li->queued[ecb->tag[1]] = NULL;
1383 li->used--;
1384 }
1385
1386 if ((ecb->flags & ECB_READY) != 0) {
1387 ecb->flags &= ~ECB_READY;
1388 TAILQ_REMOVE(&sc->ready_list, ecb, chain);
1389 }
1390}
1391
1392/*
1393 * INTERRUPT/PROTOCOL ENGINE
1394 */
1395
1396/*
1397 * Schedule an outgoing message by prioritizing it, and asserting
1398 * attention on the bus. We can only do this when we are the initiator
1399 * else there will be an illegal command interrupt.
1400 */
1401#define ncr53c9x_sched_msgout(m) \
1402 do { \
1403 NCR_MSGS(("ncr53c9x_sched_msgout %x %d", m, __LINE__)); \
1404 NCRCMD(sc, NCRCMD_SETATN); \
1405 sc->sc_flags |= NCR_ATN; \
1406 sc->sc_msgpriq |= (m); \
1407 } while (0)
1408
1409static void
1410ncr53c9x_flushfifo(struct ncr53c9x_softc *sc)
1411{
1412 NCR_TRACE(("[flushfifo] "));
1413
1414 NCRCMD(sc, NCRCMD_FLUSH);
1415
1416 if (sc->sc_phase == COMMAND_PHASE ||
1417 sc->sc_phase == MESSAGE_OUT_PHASE)
1418 DELAY(2);
1419}
1420
1421static int
1422ncr53c9x_rdfifo(struct ncr53c9x_softc *sc, int how)
1423{
1424 int i, n;
1425 u_char *buf;
1426
1427 switch(how) {
1428 case NCR_RDFIFO_START:
1429 buf = sc->sc_imess;
1430 sc->sc_imlen = 0;
1431 break;
1432 case NCR_RDFIFO_CONTINUE:
1433 buf = sc->sc_imess + sc->sc_imlen;
1434 break;
1435 default:
1436 panic("ncr53c9x_rdfifo: bad flag");
1437 break;
1438 }
1439
1440 /*
1441 * XXX buffer (sc_imess) size for message
1442 */
1443
1444 n = NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF;
1445
1446 if (sc->sc_rev == NCR_VARIANT_FAS366) {
1447 n *= 2;
1448
1449 for (i = 0; i < n; i++)
1450 buf[i] = NCR_READ_REG(sc, NCR_FIFO);
1451
1452 if (sc->sc_espstat2 & NCRFAS_STAT2_ISHUTTLE) {
1453
1454 NCR_WRITE_REG(sc, NCR_FIFO, 0);
1455 buf[i++] = NCR_READ_REG(sc, NCR_FIFO);
1456
1457 NCR_READ_REG(sc, NCR_FIFO);
1458
1459 ncr53c9x_flushfifo(sc);
1460 }
1461 } else {
1462 for (i = 0; i < n; i++)
1463 buf[i] = NCR_READ_REG(sc, NCR_FIFO);
1464 }
1465
1466 sc->sc_imlen += i;
1467
1468#if 0
1469#ifdef NCR53C9X_DEBUG
1470 {
1471 int j;
1472
1473 NCR_TRACE(("\n[rdfifo %s (%d):",
1474 (how == NCR_RDFIFO_START) ? "start" : "cont",
1475 (int)sc->sc_imlen));
1476 if (ncr53c9x_debug & NCR_SHOWTRAC) {
1477 for (j = 0; j < sc->sc_imlen; j++)
1478 printf(" %02x", sc->sc_imess[j]);
1479 printf("]\n");
1480 }
1481 }
1482#endif
1483#endif
1484 return sc->sc_imlen;
1485}
1486
1487static void
1488ncr53c9x_wrfifo(struct ncr53c9x_softc *sc, u_char *p, int len)
1489{
1490 int i;
1491
1492#ifdef NCR53C9X_DEBUG
1493 NCR_MSGS(("[wrfifo(%d):", len));
1494 if (ncr53c9x_debug & NCR_SHOWMSGS) {
1495 for (i = 0; i < len; i++)
1496 printf(" %02x", p[i]);
1497 printf("]\n");
1498 }
1499#endif
1500
1501 for (i = 0; i < len; i++) {
1502 NCR_WRITE_REG(sc, NCR_FIFO, p[i]);
1503
1504 if (sc->sc_rev == NCR_VARIANT_FAS366)
1505 NCR_WRITE_REG(sc, NCR_FIFO, 0);
1506 }
1507}
1508
1509static int
1510ncr53c9x_reselect(struct ncr53c9x_softc *sc, int message, int tagtype,
1511 int tagid)
1512{
1513 u_char selid, target, lun;
1514 struct ncr53c9x_ecb *ecb = NULL;
1515 struct ncr53c9x_tinfo *ti;
1516 struct ncr53c9x_linfo *li;
1517
1518
1519 if (sc->sc_rev == NCR_VARIANT_FAS366) {
1520 target = sc->sc_selid;
1521 } else {
1522 /*
1523 * The SCSI chip made a snapshot of the data bus
1524 * while the reselection was being negotiated.
1525 * This enables us to determine which target did
1526 * the reselect.
1527 */
1528 selid = sc->sc_selid & ~(1 << sc->sc_id);
1529 if (selid & (selid - 1)) {
1530 device_printf(sc->sc_dev, "reselect with invalid "
1531 "selid %02x; sending DEVICE RESET\n", selid);
1532 goto reset;
1533 }
1534
1535 target = ffs(selid) - 1;
1536 }
1537 lun = message & 0x07;
1538
1539 /*
1540 * Search wait queue for disconnected cmd
1541 * The list should be short, so I haven't bothered with
1542 * any more sophisticated structures than a simple
1543 * singly linked list.
1544 */
1545 ti = &sc->sc_tinfo[target];
1546 li = TINFO_LUN(ti, lun);
1547
1548 /*
1549 * We can get as far as the LUN with the IDENTIFY
1550 * message. Check to see if we're running an
1551 * un-tagged command. Otherwise ack the IDENTIFY
1552 * and wait for a tag message.
1553 */
1554 if (li != NULL) {
1555 if (li->untagged != NULL && li->busy)
1556 ecb = li->untagged;
1557 else if (tagtype != MSG_SIMPLE_Q_TAG) {
1558 /* Wait for tag to come by */
1559 sc->sc_state = NCR_IDENTIFIED;
1560 return (0);
1561 } else if (tagtype)
1562 ecb = li->queued[tagid];
1563 }
1564 if (ecb == NULL) {
1565 device_printf(sc->sc_dev, "reselect from target %d lun %d "
1566 "tag %x:%x with no nexus; sending ABORT\n",
1567 target, lun, tagtype, tagid);
1568 goto abort;
1569 }
1570
1571 /* Make this nexus active again. */
1572 sc->sc_state = NCR_CONNECTED;
1573 sc->sc_nexus = ecb;
1574 ncr53c9x_setsync(sc, ti);
1575
1576 if (ecb->flags & ECB_RESET)
1577 ncr53c9x_sched_msgout(SEND_DEV_RESET);
1578 else if (ecb->flags & ECB_ABORT)
1579 ncr53c9x_sched_msgout(SEND_ABORT);
1580
1581 /* Do an implicit RESTORE POINTERS. */
1582 sc->sc_dp = ecb->daddr;
1583 sc->sc_dleft = ecb->dleft;
1584
1585 return (0);
1586
1587reset:
1588 ncr53c9x_sched_msgout(SEND_DEV_RESET);
1589 return (1);
1590
1591abort:
1592 ncr53c9x_sched_msgout(SEND_ABORT);
1593 return (1);
1594}
1595
1596/* From NetBSD. These should go into CAM at some point */
1597#define MSG_ISEXTENDED(m) ((m) == MSG_EXTENDED)
1598#define MSG_IS1BYTE(m) \
1599 ((!MSG_ISEXTENDED(m) && (m) < 0x20) || MSG_ISIDENTIFY(m))
1600#define MSG_IS2BYTE(m) (((m) & 0xf0) == 0x20)
1601
1602static inline int
1603__verify_msg_format(u_char *p, int len)
1604{
1605
1606 if (len == 1 && MSG_IS1BYTE(p[0]))
1607 return 1;
1608 if (len == 2 && MSG_IS2BYTE(p[0]))
1609 return 1;
1610 if (len >= 3 && MSG_ISEXTENDED(p[0]) &&
1611 len == p[1] + 2)
1612 return 1;
1613
1614 return 0;
1615}
1616
1617/*
1618 * Get an incoming message as initiator.
1619 *
1620 * The SCSI bus must already be in MESSAGE_IN_PHASE and there is a
1621 * byte in the FIFO
1622 */
1623static void
1624ncr53c9x_msgin(struct ncr53c9x_softc *sc)
1625{
1626
1627 NCR_TRACE(("[ncr53c9x_msgin(curmsglen:%ld)] ", (long)sc->sc_imlen));
1628
1629 if (sc->sc_imlen == 0) {
1630 device_printf(sc->sc_dev, "msgin: no msg byte available\n");
1631 return;
1632 }
1633
1634 /*
1635 * Prepare for a new message. A message should (according
1636 * to the SCSI standard) be transmitted in one single
1637 * MESSAGE_IN_PHASE. If we have been in some other phase,
1638 * then this is a new message.
1639 */
1640 if (sc->sc_prevphase != MESSAGE_IN_PHASE &&
1641 sc->sc_state != NCR_RESELECTED) {
1642 device_printf(sc->sc_dev, "phase change, dropping message, "
1643 "prev %d, state %d\n", sc->sc_prevphase, sc->sc_state);
1644 sc->sc_flags &= ~NCR_DROP_MSGI;
1645 sc->sc_imlen = 0;
1646 }
1647
1648 /*
1649 * If we're going to reject the message, don't bother storing
1650 * the incoming bytes. But still, we need to ACK them.
1651 */
1652 if ((sc->sc_flags & NCR_DROP_MSGI) != 0) {
1653 NCRCMD(sc, NCRCMD_MSGOK);
1654 printf("<dropping msg byte %x>", sc->sc_imess[sc->sc_imlen]);
1655 return;
1656 }
1657
1658 if (sc->sc_imlen >= NCR_MAX_MSG_LEN) {
1659 ncr53c9x_sched_msgout(SEND_REJECT);
1660 sc->sc_flags |= NCR_DROP_MSGI;
1661 } else {
1662 u_char *pb;
1663 int plen;
1664
1665 switch (sc->sc_state) {
1666 /*
1667 * if received message is the first of reselection
1668 * then first byte is selid, and then message
1669 */
1670 case NCR_RESELECTED:
1671 pb = sc->sc_imess + 1;
1672 plen = sc->sc_imlen - 1;
1673 break;
1674 default:
1675 pb = sc->sc_imess;
1676 plen = sc->sc_imlen;
1677 break;
1678 }
1679
1680 if (__verify_msg_format(pb, plen))
1681 goto gotit;
1682 }
1683
1684 /* Ack what we have so far */
1685 NCRCMD(sc, NCRCMD_MSGOK);
1686 return;
1687
1688gotit:
1689 NCR_MSGS(("gotmsg(%x) state %d", sc->sc_imess[0], sc->sc_state));
1690 /* We got a complete message, flush the imess, */
1691 /* XXX nobody uses imlen below */
1692 sc->sc_imlen = 0;
1693 /*
1694 * Now we should have a complete message (1 byte, 2 byte
1695 * and moderately long extended messages). We only handle
1696 * extended messages which total length is shorter than
1697 * NCR_MAX_MSG_LEN. Longer messages will be amputated.
1698 */
1699 switch (sc->sc_state) {
1700 struct ncr53c9x_ecb *ecb;
1701 struct ncr53c9x_tinfo *ti;
1702 struct ncr53c9x_linfo *li;
1703 int lun;
1704
1705 case NCR_CONNECTED:
1706 ecb = sc->sc_nexus;
1707 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
1708
1709 switch (sc->sc_imess[0]) {
1710 case MSG_CMDCOMPLETE:
1711 NCR_MSGS(("cmdcomplete "));
1712 if (sc->sc_dleft < 0) {
1713 xpt_print_path(ecb->ccb->ccb_h.path);
1714 printf("got %ld extra bytes\n",
1715 -(long)sc->sc_dleft);
1716 sc->sc_dleft = 0;
1717 }
1718 ecb->dleft = (ecb->flags & ECB_TENTATIVE_DONE) ?
1719 0 : sc->sc_dleft;
1720 if ((ecb->flags & ECB_SENSE) == 0)
1721 ecb->ccb->csio.resid = ecb->dleft;
1722 sc->sc_state = NCR_CMDCOMPLETE;
1723 break;
1724
1725 case MSG_MESSAGE_REJECT:
1726 NCR_MSGS(("msg reject (msgout=%x) ", sc->sc_msgout));
1727 switch (sc->sc_msgout) {
1728 case SEND_TAG:
1729 /*
1730 * Target does not like tagged queuing.
1731 * - Flush the command queue
1732 * - Disable tagged queuing for the target
1733 * - Dequeue ecb from the queued array.
1734 */
1735 device_printf(sc->sc_dev, "tagged queuing "
1736 "rejected: target %d\n",
1737 ecb->ccb->ccb_h.target_id);
1738
1739 NCR_MSGS(("(rejected sent tag)"));
1740 NCRCMD(sc, NCRCMD_FLUSH);
1741 DELAY(1);
1742 ti->flags &= ~T_TAG;
1743 lun = ecb->ccb->ccb_h.target_lun;
1744 li = TINFO_LUN(ti, lun);
1745 if (ecb->tag[0] &&
1746 li->queued[ecb->tag[1]] != NULL) {
1747 li->queued[ecb->tag[1]] = NULL;
1748 li->used--;
1749 }
1750 ecb->tag[0] = ecb->tag[1] = 0;
1751 li->untagged = ecb;
1752 li->busy = 1;
1753 break;
1754
1755 case SEND_SDTR:
1756 device_printf(sc->sc_dev, "sync transfer "
1757 "rejected: target %d\n",
1758 ecb->ccb->ccb_h.target_id);
1759
1760 sc->sc_flags &= ~NCR_SYNCHNEGO;
1761 ti->flags &= ~(T_NEGOTIATE | T_SYNCMODE);
1762 ncr53c9x_setsync(sc, ti);
1763 break;
1764
1765 case SEND_WDTR:
1766 device_printf(sc->sc_dev, "wide transfer "
1767 "rejected: target %d\n",
1768 ecb->ccb->ccb_h.target_id);
1769 ti->flags &= ~(T_WIDE | T_WDTRSENT);
1770 ti->width = 0;
1771 break;
1772
1773 case SEND_INIT_DET_ERR:
1774 goto abort;
1775 }
1776 break;
1777
1778 case MSG_NOOP:
1779 NCR_MSGS(("noop "));
1780 break;
1781
1782 case MSG_HEAD_OF_Q_TAG:
1783 case MSG_SIMPLE_Q_TAG:
1784 case MSG_ORDERED_Q_TAG:
1785 NCR_MSGS(("TAG %x:%x",
1786 sc->sc_imess[0], sc->sc_imess[1]));
1787 break;
1788
1789 case MSG_DISCONNECT:
1790 NCR_MSGS(("disconnect "));
1791 ti->dconns++;
1792 sc->sc_state = NCR_DISCONNECT;
1793
1794 /*
1795 * Mark the fact that all bytes have moved. The
1796 * target may not bother to do a SAVE POINTERS
1797 * at this stage. This flag will set the residual
1798 * count to zero on MSG COMPLETE.
1799 */
1800 if (sc->sc_dleft == 0)
1801 ecb->flags |= ECB_TENTATIVE_DONE;
1802
1803 break;
1804
1805 case MSG_SAVEDATAPOINTER:
1806 NCR_MSGS(("save datapointer "));
1807 ecb->daddr = sc->sc_dp;
1808 ecb->dleft = sc->sc_dleft;
1809 break;
1810
1811 case MSG_RESTOREPOINTERS:
1812 NCR_MSGS(("restore datapointer "));
1813 sc->sc_dp = ecb->daddr;
1814 sc->sc_dleft = ecb->dleft;
1815 break;
1816
1817 case MSG_EXTENDED:
1818 NCR_MSGS(("extended(%x) ", sc->sc_imess[2]));
1819 switch (sc->sc_imess[2]) {
1820 case MSG_EXT_SDTR:
1821 NCR_MSGS(("SDTR period %d, offset %d ",
1822 sc->sc_imess[3], sc->sc_imess[4]));
1823 if (sc->sc_imess[1] != 3)
1824 goto reject;
1825 ti->period = sc->sc_imess[3];
1826 ti->offset = sc->sc_imess[4];
1827 ti->flags &= ~T_NEGOTIATE;
1828 if (sc->sc_minsync == 0 ||
1829 ti->offset == 0 ||
1830 ti->period > 124) {
1831#if 0
1832#ifdef NCR53C9X_DEBUG
1833 xpt_print_path(ecb->ccb->ccb_h.path);
1834 printf("async mode\n");
1835#endif
1836#endif
1837 ti->flags &= ~T_SYNCMODE;
1838 if ((sc->sc_flags&NCR_SYNCHNEGO) == 0) {
1839 /*
1840 * target initiated negotiation
1841 */
1842 ti->offset = 0;
1843 ncr53c9x_sched_msgout(
1844 SEND_SDTR);
1845 }
1846 } else {
1847 int p;
1848
1849 p = ncr53c9x_stp2cpb(sc, ti->period);
1850 ti->period = ncr53c9x_cpb2stp(sc, p);
1851 if ((sc->sc_flags&NCR_SYNCHNEGO) == 0) {
1852 /*
1853 * target initiated negotiation
1854 */
|
1796 if (ti->period <
1797 sc->sc_minsync)
| 1855 if (ti->period < sc->sc_minsync)
|
1798 ti->period =
1799 sc->sc_minsync;
1800 if (ti->offset > 15)
1801 ti->offset = 15;
1802 ti->flags &= ~T_SYNCMODE;
1803 ncr53c9x_sched_msgout(
1804 SEND_SDTR);
1805 } else {
1806 /* we are sync */
1807 ti->flags |= T_SYNCMODE;
1808 }
1809 }
1810 sc->sc_flags &= ~NCR_SYNCHNEGO;
1811 ncr53c9x_setsync(sc, ti);
1812 break;
1813
1814 case MSG_EXT_WDTR:
1815#ifdef NCR53C9X_DEBUG
1816 device_printf(sc->sc_dev, "wide mode %d\n",
1817 sc->sc_imess[3]);
1818#endif
1819 if (sc->sc_imess[3] == 1) {
1820 ti->cfg3 |= NCRFASCFG3_EWIDE;
1821 ncr53c9x_setsync(sc, ti);
1822 } else
1823 ti->width = 0;
1824 /*
1825 * Device started width negotiation.
1826 */
1827 if (!(ti->flags & T_WDTRSENT))
1828 ncr53c9x_sched_msgout(SEND_WDTR);
1829 ti->flags &= ~(T_WIDE | T_WDTRSENT);
1830 break;
1831 default:
1832 xpt_print_path(ecb->ccb->ccb_h.path);
1833 printf("unrecognized MESSAGE EXTENDED;"
1834 " sending REJECT\n");
1835 goto reject;
1836 }
1837 break;
1838
1839 default:
1840 NCR_MSGS(("ident "));
1841 xpt_print_path(ecb->ccb->ccb_h.path);
1842 printf("unrecognized MESSAGE; sending REJECT\n");
1843 reject:
1844 ncr53c9x_sched_msgout(SEND_REJECT);
1845 break;
1846 }
1847 break;
1848
1849 case NCR_IDENTIFIED:
1850 /*
1851 * IDENTIFY message was received and queue tag is expected now
1852 */
1853 if ((sc->sc_imess[0] != MSG_SIMPLE_Q_TAG) ||
1854 (sc->sc_msgify == 0)) {
1855 device_printf(sc->sc_dev, "TAG reselect without "
1856 "IDENTIFY; MSG %x; sending DEVICE RESET\n",
1857 sc->sc_imess[0]);
1858 goto reset;
1859 }
1860 (void) ncr53c9x_reselect(sc, sc->sc_msgify,
1861 sc->sc_imess[0], sc->sc_imess[1]);
1862 break;
1863
1864 case NCR_RESELECTED:
1865 if (MSG_ISIDENTIFY(sc->sc_imess[1])) {
1866 sc->sc_msgify = sc->sc_imess[1];
1867 } else {
1868 device_printf(sc->sc_dev, "reselect without IDENTIFY;"
1869 " MSG %x; sending DEVICE RESET\n", sc->sc_imess[1]);
1870 goto reset;
1871 }
1872 (void) ncr53c9x_reselect(sc, sc->sc_msgify, 0, 0);
1873 break;
1874
1875 default:
1876 device_printf(sc->sc_dev, "unexpected MESSAGE IN; "
1877 "sending DEVICE RESET\n");
1878 reset:
1879 ncr53c9x_sched_msgout(SEND_DEV_RESET);
1880 break;
1881
1882 abort:
1883 ncr53c9x_sched_msgout(SEND_ABORT);
1884 break;
1885 }
1886
1887 /* if we have more messages to send set ATN */
1888 if (sc->sc_msgpriq)
1889 NCRCMD(sc, NCRCMD_SETATN);
1890
1891 /* Ack last message byte */
1892 NCRCMD(sc, NCRCMD_MSGOK);
1893
1894 /* Done, reset message pointer. */
1895 sc->sc_flags &= ~NCR_DROP_MSGI;
1896 sc->sc_imlen = 0;
1897}
1898
1899
1900/*
1901 * Send the highest priority, scheduled message
1902 */
1903static void
1904ncr53c9x_msgout(struct ncr53c9x_softc *sc)
1905{
1906 struct ncr53c9x_tinfo *ti;
1907 struct ncr53c9x_ecb *ecb;
1908 size_t size;
1909
1910 NCR_TRACE(("[ncr53c9x_msgout(priq:%x, prevphase:%x)]",
1911 sc->sc_msgpriq, sc->sc_prevphase));
1912
1913 /*
1914 * XXX - the NCR_ATN flag is not in sync with the actual ATN
1915 * condition on the SCSI bus. The 53c9x chip
1916 * automatically turns off ATN before sending the
1917 * message byte. (See also the comment below in the
1918 * default case when picking out a message to send.)
1919 */
1920 if (sc->sc_flags & NCR_ATN) {
1921 if (sc->sc_prevphase != MESSAGE_OUT_PHASE) {
1922 new:
1923 NCRCMD(sc, NCRCMD_FLUSH);
1924/* DELAY(1); */
1925 sc->sc_msgoutq = 0;
1926 sc->sc_omlen = 0;
1927 }
1928 } else {
1929 if (sc->sc_prevphase == MESSAGE_OUT_PHASE) {
1930 ncr53c9x_sched_msgout(sc->sc_msgoutq);
1931 goto new;
1932 } else {
1933 device_printf(sc->sc_dev, "at line %d: unexpected "
1934 "MESSAGE OUT phase\n", __LINE__);
1935 }
1936 }
1937
1938 if (sc->sc_omlen == 0) {
1939 /* Pick up highest priority message */
1940 sc->sc_msgout = sc->sc_msgpriq & -sc->sc_msgpriq;
1941 sc->sc_msgoutq |= sc->sc_msgout;
1942 sc->sc_msgpriq &= ~sc->sc_msgout;
1943 sc->sc_omlen = 1; /* "Default" message len */
1944 switch (sc->sc_msgout) {
1945 case SEND_SDTR:
1946 ecb = sc->sc_nexus;
1947 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
1948 sc->sc_omess[0] = MSG_EXTENDED;
1949 sc->sc_omess[1] = MSG_EXT_SDTR_LEN;
1950 sc->sc_omess[2] = MSG_EXT_SDTR;
1951 sc->sc_omess[3] = ti->period;
1952 sc->sc_omess[4] = ti->offset;
1953 sc->sc_omlen = 5;
1954 if ((sc->sc_flags & NCR_SYNCHNEGO) == 0) {
1955 ti->flags |= T_SYNCMODE;
1956 ncr53c9x_setsync(sc, ti);
1957 }
1958 break;
1959 case SEND_WDTR:
1960 ecb = sc->sc_nexus;
1961 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
1962 sc->sc_omess[0] = MSG_EXTENDED;
1963 sc->sc_omess[1] = MSG_EXT_WDTR_LEN;
1964 sc->sc_omess[2] = MSG_EXT_WDTR;
1965 sc->sc_omess[3] = ti->width;
1966 sc->sc_omlen = 4;
1967 break;
1968 case SEND_IDENTIFY:
1969 if (sc->sc_state != NCR_CONNECTED) {
1970 device_printf(sc->sc_dev, "at line %d: no "
1971 "nexus\n", __LINE__);
1972 }
1973 ecb = sc->sc_nexus;
1974 sc->sc_omess[0] =
1975 MSG_IDENTIFY(ecb->ccb->ccb_h.target_lun, 0);
1976 break;
1977 case SEND_TAG:
1978 if (sc->sc_state != NCR_CONNECTED) {
1979 device_printf(sc->sc_dev, "at line %d: no "
1980 "nexus\n", __LINE__);
1981 }
1982 ecb = sc->sc_nexus;
1983 sc->sc_omess[0] = ecb->tag[0];
1984 sc->sc_omess[1] = ecb->tag[1];
1985 sc->sc_omlen = 2;
1986 break;
1987 case SEND_DEV_RESET:
1988 sc->sc_flags |= NCR_ABORTING;
1989 sc->sc_omess[0] = MSG_BUS_DEV_RESET;
1990 ecb = sc->sc_nexus;
1991 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
1992 ti->flags &= ~T_SYNCMODE;
1993 if ((ti->flags & T_SYNCHOFF) == 0)
1994 /* We can re-start sync negotiation */
1995 ti->flags |= T_NEGOTIATE;
1996 break;
1997 case SEND_PARITY_ERROR:
1998 sc->sc_omess[0] = MSG_PARITY_ERROR;
1999 break;
2000 case SEND_ABORT:
2001 sc->sc_flags |= NCR_ABORTING;
2002 sc->sc_omess[0] = MSG_ABORT;
2003 break;
2004 case SEND_INIT_DET_ERR:
2005 sc->sc_omess[0] = MSG_INITIATOR_DET_ERR;
2006 break;
2007 case SEND_REJECT:
2008 sc->sc_omess[0] = MSG_MESSAGE_REJECT;
2009 break;
2010 default:
2011 /*
2012 * We normally do not get here, since the chip
2013 * automatically turns off ATN before the last
2014 * byte of a message is sent to the target.
2015 * However, if the target rejects our (multi-byte)
2016 * message early by switching to MSG IN phase
2017 * ATN remains on, so the target may return to
2018 * MSG OUT phase. If there are no scheduled messages
2019 * left we send a NO-OP.
2020 *
2021 * XXX - Note that this leaves no useful purpose for
2022 * the NCR_ATN flag.
2023 */
2024 sc->sc_flags &= ~NCR_ATN;
2025 sc->sc_omess[0] = MSG_NOOP;
2026 break;
2027 }
2028 sc->sc_omp = sc->sc_omess;
2029 }
2030
2031#ifdef DEBUG
2032 if (ncr53c9x_debug & NCR_SHOWMSGS) {
2033 int i;
2034
2035 NCR_MSGS(("<msgout:"));
2036 for (i = 0; i < sc->sc_omlen; i++)
2037 NCR_MSGS((" %02x", sc->sc_omess[i]));
2038 NCR_MSGS(("> "));
2039 }
2040#endif
2041 if (sc->sc_rev == NCR_VARIANT_FAS366) {
2042 /*
2043 * XXX fifo size
2044 */
2045 ncr53c9x_flushfifo(sc);
2046 ncr53c9x_wrfifo(sc, sc->sc_omp, sc->sc_omlen);
2047 NCRCMD(sc, NCRCMD_TRANS);
2048 } else {
2049 /* (re)send the message */
2050 size = min(sc->sc_omlen, sc->sc_maxxfer);
2051 NCRDMA_SETUP(sc, &sc->sc_omp, &sc->sc_omlen, 0, &size);
2052 /* Program the SCSI counter */
2053 NCR_SET_COUNT(sc, size);
2054
2055 /* Load the count in and start the message-out transfer */
2056 NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
2057 NCRCMD(sc, NCRCMD_TRANS|NCRCMD_DMA);
2058 NCRDMA_GO(sc);
2059 }
2060}
2061
2062/*
2063 * This is the most critical part of the driver, and has to know
2064 * how to deal with *all* error conditions and phases from the SCSI
2065 * bus. If there are no errors and the DMA was active, then call the
2066 * DMA pseudo-interrupt handler. If this returns 1, then that was it
2067 * and we can return from here without further processing.
2068 *
2069 * Most of this needs verifying.
2070 */
2071void
2072ncr53c9x_intr(void *arg)
2073{
2074 struct ncr53c9x_softc *sc = arg;
2075 struct ncr53c9x_ecb *ecb;
2076 struct ncr53c9x_tinfo *ti;
2077 size_t size;
2078 int nfifo;
2079
2080 NCR_INTS(("[ncr53c9x_intr: state %d]", sc->sc_state));
2081
2082 if (!NCRDMA_ISINTR(sc))
2083 return;
2084
2085 mtx_lock(&sc->sc_lock);
2086again:
2087 /* and what do the registers say... */
2088 ncr53c9x_readregs(sc);
2089
2090 /*
2091 * At the moment, only a SCSI Bus Reset or Illegal
2092 * Command are classed as errors. A disconnect is a
2093 * valid condition, and we let the code check is the
2094 * "NCR_BUSFREE_OK" flag was set before declaring it
2095 * and error.
2096 *
2097 * Also, the status register tells us about "Gross
2098 * Errors" and "Parity errors". Only the Gross Error
2099 * is really bad, and the parity errors are dealt
2100 * with later
2101 *
2102 * TODO
2103 * If there are too many parity error, go to slow
2104 * cable mode ?
2105 */
2106
2107 /* SCSI Reset */
2108 if ((sc->sc_espintr & NCRINTR_SBR) != 0) {
2109 if ((NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) != 0) {
2110 NCRCMD(sc, NCRCMD_FLUSH);
2111 DELAY(1);
2112 }
2113 if (sc->sc_state != NCR_SBR) {
2114 device_printf(sc->sc_dev, "SCSI bus reset\n");
2115 ncr53c9x_init(sc, 0); /* Restart everything */
2116 goto out;
2117 }
2118#if 0
2119/*XXX*/ printf("<expected bus reset: "
2120 "[intr %x, stat %x, step %d]>\n",
2121 sc->sc_espintr, sc->sc_espstat, sc->sc_espstep);
2122#endif
2123 if (sc->sc_nexus != NULL)
2124 panic("%s: nexus in reset state",
2125 device_get_nameunit(sc->sc_dev));
2126 goto sched;
2127 }
2128
2129 ecb = sc->sc_nexus;
2130
2131#define NCRINTR_ERR (NCRINTR_SBR|NCRINTR_ILL)
2132 if (sc->sc_espintr & NCRINTR_ERR ||
2133 sc->sc_espstat & NCRSTAT_GE) {
2134
2135 if ((sc->sc_espstat & NCRSTAT_GE) != 0) {
2136 /* Gross Error; no target ? */
2137 if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
2138 NCRCMD(sc, NCRCMD_FLUSH);
2139 DELAY(1);
2140 }
2141 if (sc->sc_state == NCR_CONNECTED ||
2142 sc->sc_state == NCR_SELECTING) {
2143 ecb->ccb->ccb_h.status = CAM_SEL_TIMEOUT;
2144 ncr53c9x_done(sc, ecb);
2145 }
2146 goto out;
2147 }
2148
2149 if ((sc->sc_espintr & NCRINTR_ILL) != 0) {
2150 if ((sc->sc_flags & NCR_EXPECT_ILLCMD) != 0) {
2151 /*
2152 * Eat away "Illegal command" interrupt
2153 * on a ESP100 caused by a re-selection
2154 * while we were trying to select
2155 * another target.
2156 */
2157#ifdef DEBUG
2158 device_printf(sc->sc_dev, "ESP100 work-around "
2159 "activated\n");
2160#endif
2161 sc->sc_flags &= ~NCR_EXPECT_ILLCMD;
2162 goto out;
2163 }
2164 /* illegal command, out of sync ? */
2165 device_printf(sc->sc_dev, "illegal command: 0x%x "
2166 "(state %d, phase %x, prevphase %x)\n",
2167 sc->sc_lastcmd,
2168 sc->sc_state, sc->sc_phase, sc->sc_prevphase);
2169 if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
2170 NCRCMD(sc, NCRCMD_FLUSH);
2171 DELAY(1);
2172 }
2173 ncr53c9x_init(sc, 1); /* Restart everything */
2174 goto out;
2175 }
2176 }
2177 sc->sc_flags &= ~NCR_EXPECT_ILLCMD;
2178
2179 /*
2180 * Call if DMA is active.
2181 *
2182 * If DMA_INTR returns true, then maybe go 'round the loop
2183 * again in case there is no more DMA queued, but a phase
2184 * change is expected.
2185 */
2186 if (NCRDMA_ISACTIVE(sc)) {
2187 int r = NCRDMA_INTR(sc);
2188 if (r == -1) {
2189 device_printf(sc->sc_dev, "DMA error; resetting\n");
2190 ncr53c9x_init(sc, 1);
2191 goto out;
2192 }
2193 /* If DMA active here, then go back to work... */
2194 if (NCRDMA_ISACTIVE(sc))
2195 goto out;
2196
2197 if ((sc->sc_espstat & NCRSTAT_TC) == 0) {
2198 /*
2199 * DMA not completed. If we can not find a
2200 * acceptable explanation, print a diagnostic.
2201 */
2202 if (sc->sc_state == NCR_SELECTING)
2203 /*
2204 * This can happen if we are reselected
2205 * while using DMA to select a target.
2206 */
2207 /*void*/;
2208 else if (sc->sc_prevphase == MESSAGE_OUT_PHASE) {
2209 /*
2210 * Our (multi-byte) message (eg SDTR) was
2211 * interrupted by the target to send
2212 * a MSG REJECT.
2213 * Print diagnostic if current phase
2214 * is not MESSAGE IN.
2215 */
2216 if (sc->sc_phase != MESSAGE_IN_PHASE)
2217 device_printf(sc->sc_dev,"!TC on MSGOUT"
2218 " [intr %x, stat %x, step %d]"
2219 " prevphase %x, resid %lx\n",
2220 sc->sc_espintr,
2221 sc->sc_espstat,
2222 sc->sc_espstep,
2223 sc->sc_prevphase,
2224 (u_long)sc->sc_omlen);
2225 } else if (sc->sc_dleft == 0) {
2226 /*
2227 * The DMA operation was started for
2228 * a DATA transfer. Print a diagnostic
2229 * if the DMA counter and TC bit
2230 * appear to be out of sync.
2231 *
2232 * XXX This is fatal and usually means that
2233 * the DMA engine is hopelessly out of
2234 * sync with reality. A disk is likely
2235 * getting spammed at this point.
2236 */
2237 device_printf(sc->sc_dev, "!TC on DATA XFER"
2238 " [intr %x, stat %x, step %d]"
2239 " prevphase %x, resid %x\n",
2240 sc->sc_espintr,
2241 sc->sc_espstat,
2242 sc->sc_espstep,
2243 sc->sc_prevphase,
2244 ecb ? ecb->dleft : -1);
2245 panic("esp: unrecoverable DMA error");
2246 }
2247 }
2248 }
2249
2250 /*
2251 * Check for less serious errors.
2252 */
2253 if ((sc->sc_espstat & NCRSTAT_PE) != 0) {
2254 device_printf(sc->sc_dev, "SCSI bus parity error\n");
2255 if (sc->sc_prevphase == MESSAGE_IN_PHASE)
2256 ncr53c9x_sched_msgout(SEND_PARITY_ERROR);
2257 else
2258 ncr53c9x_sched_msgout(SEND_INIT_DET_ERR);
2259 }
2260
2261 if ((sc->sc_espintr & NCRINTR_DIS) != 0) {
2262 sc->sc_msgify = 0;
2263 NCR_INTS(("<DISC [intr %x, stat %x, step %d]>",
2264 sc->sc_espintr,sc->sc_espstat,sc->sc_espstep));
2265 if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
2266 NCRCMD(sc, NCRCMD_FLUSH);
2267/* DELAY(1); */
2268 }
2269 /*
2270 * This command must (apparently) be issued within
2271 * 250mS of a disconnect. So here you are...
2272 */
2273 NCRCMD(sc, NCRCMD_ENSEL);
2274
2275 switch (sc->sc_state) {
2276 case NCR_RESELECTED:
2277 goto sched;
2278
2279 case NCR_SELECTING:
2280 {
2281 struct ncr53c9x_linfo *li;
2282
2283 ecb->ccb->ccb_h.status = CAM_SEL_TIMEOUT;
2284
2285 /* Selection timeout -- discard all LUNs if empty */
2286 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
2287 li = LIST_FIRST(&ti->luns);
2288 while (li != NULL) {
2289 if (li->untagged == NULL && li->used == 0) {
2290 if (li->lun < NCR_NLUN)
2291 ti->lun[li->lun] = NULL;
2292 LIST_REMOVE(li, link);
2293 free(li, M_DEVBUF);
2294 /*
2295 * Restart the search at the beginning
2296 */
2297 li = LIST_FIRST(&ti->luns);
2298 continue;
2299 }
2300 li = LIST_NEXT(li, link);
2301 }
2302 goto finish;
2303 }
2304 case NCR_CONNECTED:
2305 if ((sc->sc_flags & NCR_SYNCHNEGO) != 0) {
2306#ifdef NCR53C9X_DEBUG
2307 if (ecb != NULL)
2308 xpt_print_path(ecb->ccb->ccb_h.path);
2309 printf("sync nego not completed!\n");
2310#endif
2311 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
2312 sc->sc_flags &= ~NCR_SYNCHNEGO;
2313 ti->flags &= ~(T_NEGOTIATE | T_SYNCMODE);
2314 }
2315
2316 /* it may be OK to disconnect */
2317 if ((sc->sc_flags & NCR_ABORTING) == 0) {
2318 /*
2319 * Section 5.1.1 of the SCSI 2 spec
2320 * suggests issuing a REQUEST SENSE
2321 * following an unexpected disconnect.
2322 * Some devices go into a contingent
2323 * allegiance condition when
2324 * disconnecting, and this is necessary
2325 * to clean up their state.
2326 */
2327 device_printf(sc->sc_dev, "unexpected "
2328 "disconnect [state %d, intr %x, stat %x, "
2329 "phase(c %x, p %x)]; ", sc->sc_state,
2330 sc->sc_espintr, sc->sc_espstat,
2331 sc->sc_phase, sc->sc_prevphase);
2332
2333 /*
2334 * XXX This will cause a chip reset and will
2335 * prevent us from finding out the real
2336 * problem with the device. However, it's
2337 * neccessary until a way can be found to
2338 * safely cancel the DMA that is in
2339 * progress.
2340 */
2341 if (1 || (ecb->flags & ECB_SENSE) != 0) {
2342 printf("resetting\n");
2343 goto reset;
2344 }
2345 printf("sending REQUEST SENSE\n");
2346 untimeout(ncr53c9x_timeout, ecb,
2347 ecb->ccb->ccb_h.timeout_ch);
2348 ncr53c9x_sense(sc, ecb);
2349 goto out;
2350 }
2351
2352 ecb->ccb->ccb_h.status = CAM_CMD_TIMEOUT;
2353 goto finish;
2354
2355 case NCR_DISCONNECT:
2356 sc->sc_nexus = NULL;
2357 goto sched;
2358
2359 case NCR_CMDCOMPLETE:
2360 ecb->ccb->ccb_h.status = CAM_REQ_CMP;
2361 goto finish;
2362 }
2363 }
2364
2365 switch (sc->sc_state) {
2366
2367 case NCR_SBR:
2368 device_printf(sc->sc_dev, "waiting for Bus Reset to happen\n");
2369 goto out;
2370
2371 case NCR_RESELECTED:
2372 /*
2373 * we must be continuing a message ?
2374 */
2375 device_printf(sc->sc_dev, "unhandled reselect continuation, "
2376 "state %d, intr %02x\n", sc->sc_state, sc->sc_espintr);
2377 ncr53c9x_init(sc, 1);
2378 goto out;
2379 break;
2380
2381 case NCR_IDENTIFIED:
2382 ecb = sc->sc_nexus;
2383 if (sc->sc_phase != MESSAGE_IN_PHASE) {
2384 int i = (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF);
2385 /*
2386 * Things are seriously screwed up.
2387 * Pull the brakes, i.e. reset
2388 */
2389 device_printf(sc->sc_dev, "target didn't send tag: %d "
2390 "bytes in fifo\n", i);
2391 /* Drain and display fifo */
2392 while (i-- > 0)
2393 printf("[%d] ", NCR_READ_REG(sc, NCR_FIFO));
2394
2395 ncr53c9x_init(sc, 1);
2396 goto out;
2397 } else
2398 goto msgin;
2399
2400 case NCR_IDLE:
2401 case NCR_SELECTING:
2402 ecb = sc->sc_nexus;
2403 if (sc->sc_espintr & NCRINTR_RESEL) {
2404 sc->sc_msgpriq = sc->sc_msgout = sc->sc_msgoutq = 0;
2405 sc->sc_flags = 0;
2406 /*
2407 * If we're trying to select a
2408 * target ourselves, push our command
2409 * back into the ready list.
2410 */
2411 if (sc->sc_state == NCR_SELECTING) {
2412 NCR_INTS(("backoff selector "));
2413 untimeout(ncr53c9x_timeout, ecb,
2414 ecb->ccb->ccb_h.timeout_ch);
2415 ncr53c9x_dequeue(sc, ecb);
2416 TAILQ_INSERT_HEAD(&sc->ready_list, ecb, chain);
2417 ecb->flags |= ECB_READY;
2418 ecb = sc->sc_nexus = NULL;
2419 }
2420 sc->sc_state = NCR_RESELECTED;
2421 if (sc->sc_phase != MESSAGE_IN_PHASE) {
2422 /*
2423 * Things are seriously screwed up.
2424 * Pull the brakes, i.e. reset
2425 */
2426 device_printf(sc->sc_dev, "target didn't "
2427 "identify\n");
2428 ncr53c9x_init(sc, 1);
2429 goto out;
2430 }
2431 /*
2432 * The C90 only inhibits FIFO writes until reselection
2433 * is complete instead of waiting until the interrupt
2434 * status register has been read. So, if the reselect
2435 * happens while we were entering command bytes (for
2436 * another target) some of those bytes can appear in
2437 * the FIFO here, after the interrupt is taken.
2438 *
2439 * To remedy this situation, pull the Selection ID
2440 * and Identify message from the FIFO directly, and
2441 * ignore any extraneous fifo contents. Also, set
2442 * a flag that allows one Illegal Command Interrupt
2443 * to occur which the chip also generates as a result
2444 * of writing to the FIFO during a reselect.
2445 */
2446 if (sc->sc_rev == NCR_VARIANT_ESP100) {
2447 nfifo = NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF;
2448 sc->sc_imess[0] = NCR_READ_REG(sc, NCR_FIFO);
2449 sc->sc_imess[1] = NCR_READ_REG(sc, NCR_FIFO);
2450 sc->sc_imlen = 2;
2451 if (nfifo != 2) {
2452 /* Flush the rest */
2453 NCRCMD(sc, NCRCMD_FLUSH);
2454 }
2455 sc->sc_flags |= NCR_EXPECT_ILLCMD;
2456 if (nfifo > 2)
2457 nfifo = 2; /* We fixed it.. */
2458 } else
2459 nfifo = ncr53c9x_rdfifo(sc, NCR_RDFIFO_START);
2460
2461 if (nfifo != 2) {
2462 device_printf(sc->sc_dev, "RESELECT: %d bytes "
2463 "in FIFO! [intr %x, stat %x, step %d, "
2464 "prevphase %x]\n",
2465 nfifo,
2466 sc->sc_espintr,
2467 sc->sc_espstat,
2468 sc->sc_espstep,
2469 sc->sc_prevphase);
2470 ncr53c9x_init(sc, 1);
2471 goto out;
2472 }
2473 sc->sc_selid = sc->sc_imess[0];
2474 NCR_INTS(("selid=%02x ", sc->sc_selid));
2475
2476 /* Handle identify message */
2477 ncr53c9x_msgin(sc);
2478
2479 if (sc->sc_state != NCR_CONNECTED &&
2480 sc->sc_state != NCR_IDENTIFIED) {
2481 /* IDENTIFY fail?! */
2482 device_printf(sc->sc_dev, "identify failed, "
2483 "state %d, intr %02x\n", sc->sc_state,
2484 sc->sc_espintr);
2485 ncr53c9x_init(sc, 1);
2486 goto out;
2487 }
2488 goto shortcut; /* ie. next phase expected soon */
2489 }
2490
2491#define NCRINTR_DONE (NCRINTR_FC|NCRINTR_BS)
2492 if ((sc->sc_espintr & NCRINTR_DONE) == NCRINTR_DONE) {
2493 /*
2494 * Arbitration won; examine the `step' register
2495 * to determine how far the selection could progress.
2496 */
| 1856 ti->period =
1857 sc->sc_minsync;
1858 if (ti->offset > 15)
1859 ti->offset = 15;
1860 ti->flags &= ~T_SYNCMODE;
1861 ncr53c9x_sched_msgout(
1862 SEND_SDTR);
1863 } else {
1864 /* we are sync */
1865 ti->flags |= T_SYNCMODE;
1866 }
1867 }
1868 sc->sc_flags &= ~NCR_SYNCHNEGO;
1869 ncr53c9x_setsync(sc, ti);
1870 break;
1871
1872 case MSG_EXT_WDTR:
1873#ifdef NCR53C9X_DEBUG
1874 device_printf(sc->sc_dev, "wide mode %d\n",
1875 sc->sc_imess[3]);
1876#endif
1877 if (sc->sc_imess[3] == 1) {
1878 ti->cfg3 |= NCRFASCFG3_EWIDE;
1879 ncr53c9x_setsync(sc, ti);
1880 } else
1881 ti->width = 0;
1882 /*
1883 * Device started width negotiation.
1884 */
1885 if (!(ti->flags & T_WDTRSENT))
1886 ncr53c9x_sched_msgout(SEND_WDTR);
1887 ti->flags &= ~(T_WIDE | T_WDTRSENT);
1888 break;
1889 default:
1890 xpt_print_path(ecb->ccb->ccb_h.path);
1891 printf("unrecognized MESSAGE EXTENDED;"
1892 " sending REJECT\n");
1893 goto reject;
1894 }
1895 break;
1896
1897 default:
1898 NCR_MSGS(("ident "));
1899 xpt_print_path(ecb->ccb->ccb_h.path);
1900 printf("unrecognized MESSAGE; sending REJECT\n");
1901 reject:
1902 ncr53c9x_sched_msgout(SEND_REJECT);
1903 break;
1904 }
1905 break;
1906
1907 case NCR_IDENTIFIED:
1908 /*
1909 * IDENTIFY message was received and queue tag is expected now
1910 */
1911 if ((sc->sc_imess[0] != MSG_SIMPLE_Q_TAG) ||
1912 (sc->sc_msgify == 0)) {
1913 device_printf(sc->sc_dev, "TAG reselect without "
1914 "IDENTIFY; MSG %x; sending DEVICE RESET\n",
1915 sc->sc_imess[0]);
1916 goto reset;
1917 }
1918 (void) ncr53c9x_reselect(sc, sc->sc_msgify,
1919 sc->sc_imess[0], sc->sc_imess[1]);
1920 break;
1921
1922 case NCR_RESELECTED:
1923 if (MSG_ISIDENTIFY(sc->sc_imess[1])) {
1924 sc->sc_msgify = sc->sc_imess[1];
1925 } else {
1926 device_printf(sc->sc_dev, "reselect without IDENTIFY;"
1927 " MSG %x; sending DEVICE RESET\n", sc->sc_imess[1]);
1928 goto reset;
1929 }
1930 (void) ncr53c9x_reselect(sc, sc->sc_msgify, 0, 0);
1931 break;
1932
1933 default:
1934 device_printf(sc->sc_dev, "unexpected MESSAGE IN; "
1935 "sending DEVICE RESET\n");
1936 reset:
1937 ncr53c9x_sched_msgout(SEND_DEV_RESET);
1938 break;
1939
1940 abort:
1941 ncr53c9x_sched_msgout(SEND_ABORT);
1942 break;
1943 }
1944
1945 /* if we have more messages to send set ATN */
1946 if (sc->sc_msgpriq)
1947 NCRCMD(sc, NCRCMD_SETATN);
1948
1949 /* Ack last message byte */
1950 NCRCMD(sc, NCRCMD_MSGOK);
1951
1952 /* Done, reset message pointer. */
1953 sc->sc_flags &= ~NCR_DROP_MSGI;
1954 sc->sc_imlen = 0;
1955}
1956
1957
1958/*
1959 * Send the highest priority, scheduled message
1960 */
1961static void
1962ncr53c9x_msgout(struct ncr53c9x_softc *sc)
1963{
1964 struct ncr53c9x_tinfo *ti;
1965 struct ncr53c9x_ecb *ecb;
1966 size_t size;
1967
1968 NCR_TRACE(("[ncr53c9x_msgout(priq:%x, prevphase:%x)]",
1969 sc->sc_msgpriq, sc->sc_prevphase));
1970
1971 /*
1972 * XXX - the NCR_ATN flag is not in sync with the actual ATN
1973 * condition on the SCSI bus. The 53c9x chip
1974 * automatically turns off ATN before sending the
1975 * message byte. (See also the comment below in the
1976 * default case when picking out a message to send.)
1977 */
1978 if (sc->sc_flags & NCR_ATN) {
1979 if (sc->sc_prevphase != MESSAGE_OUT_PHASE) {
1980 new:
1981 NCRCMD(sc, NCRCMD_FLUSH);
1982/* DELAY(1); */
1983 sc->sc_msgoutq = 0;
1984 sc->sc_omlen = 0;
1985 }
1986 } else {
1987 if (sc->sc_prevphase == MESSAGE_OUT_PHASE) {
1988 ncr53c9x_sched_msgout(sc->sc_msgoutq);
1989 goto new;
1990 } else {
1991 device_printf(sc->sc_dev, "at line %d: unexpected "
1992 "MESSAGE OUT phase\n", __LINE__);
1993 }
1994 }
1995
1996 if (sc->sc_omlen == 0) {
1997 /* Pick up highest priority message */
1998 sc->sc_msgout = sc->sc_msgpriq & -sc->sc_msgpriq;
1999 sc->sc_msgoutq |= sc->sc_msgout;
2000 sc->sc_msgpriq &= ~sc->sc_msgout;
2001 sc->sc_omlen = 1; /* "Default" message len */
2002 switch (sc->sc_msgout) {
2003 case SEND_SDTR:
2004 ecb = sc->sc_nexus;
2005 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
2006 sc->sc_omess[0] = MSG_EXTENDED;
2007 sc->sc_omess[1] = MSG_EXT_SDTR_LEN;
2008 sc->sc_omess[2] = MSG_EXT_SDTR;
2009 sc->sc_omess[3] = ti->period;
2010 sc->sc_omess[4] = ti->offset;
2011 sc->sc_omlen = 5;
2012 if ((sc->sc_flags & NCR_SYNCHNEGO) == 0) {
2013 ti->flags |= T_SYNCMODE;
2014 ncr53c9x_setsync(sc, ti);
2015 }
2016 break;
2017 case SEND_WDTR:
2018 ecb = sc->sc_nexus;
2019 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
2020 sc->sc_omess[0] = MSG_EXTENDED;
2021 sc->sc_omess[1] = MSG_EXT_WDTR_LEN;
2022 sc->sc_omess[2] = MSG_EXT_WDTR;
2023 sc->sc_omess[3] = ti->width;
2024 sc->sc_omlen = 4;
2025 break;
2026 case SEND_IDENTIFY:
2027 if (sc->sc_state != NCR_CONNECTED) {
2028 device_printf(sc->sc_dev, "at line %d: no "
2029 "nexus\n", __LINE__);
2030 }
2031 ecb = sc->sc_nexus;
2032 sc->sc_omess[0] =
2033 MSG_IDENTIFY(ecb->ccb->ccb_h.target_lun, 0);
2034 break;
2035 case SEND_TAG:
2036 if (sc->sc_state != NCR_CONNECTED) {
2037 device_printf(sc->sc_dev, "at line %d: no "
2038 "nexus\n", __LINE__);
2039 }
2040 ecb = sc->sc_nexus;
2041 sc->sc_omess[0] = ecb->tag[0];
2042 sc->sc_omess[1] = ecb->tag[1];
2043 sc->sc_omlen = 2;
2044 break;
2045 case SEND_DEV_RESET:
2046 sc->sc_flags |= NCR_ABORTING;
2047 sc->sc_omess[0] = MSG_BUS_DEV_RESET;
2048 ecb = sc->sc_nexus;
2049 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
2050 ti->flags &= ~T_SYNCMODE;
2051 if ((ti->flags & T_SYNCHOFF) == 0)
2052 /* We can re-start sync negotiation */
2053 ti->flags |= T_NEGOTIATE;
2054 break;
2055 case SEND_PARITY_ERROR:
2056 sc->sc_omess[0] = MSG_PARITY_ERROR;
2057 break;
2058 case SEND_ABORT:
2059 sc->sc_flags |= NCR_ABORTING;
2060 sc->sc_omess[0] = MSG_ABORT;
2061 break;
2062 case SEND_INIT_DET_ERR:
2063 sc->sc_omess[0] = MSG_INITIATOR_DET_ERR;
2064 break;
2065 case SEND_REJECT:
2066 sc->sc_omess[0] = MSG_MESSAGE_REJECT;
2067 break;
2068 default:
2069 /*
2070 * We normally do not get here, since the chip
2071 * automatically turns off ATN before the last
2072 * byte of a message is sent to the target.
2073 * However, if the target rejects our (multi-byte)
2074 * message early by switching to MSG IN phase
2075 * ATN remains on, so the target may return to
2076 * MSG OUT phase. If there are no scheduled messages
2077 * left we send a NO-OP.
2078 *
2079 * XXX - Note that this leaves no useful purpose for
2080 * the NCR_ATN flag.
2081 */
2082 sc->sc_flags &= ~NCR_ATN;
2083 sc->sc_omess[0] = MSG_NOOP;
2084 break;
2085 }
2086 sc->sc_omp = sc->sc_omess;
2087 }
2088
2089#ifdef DEBUG
2090 if (ncr53c9x_debug & NCR_SHOWMSGS) {
2091 int i;
2092
2093 NCR_MSGS(("<msgout:"));
2094 for (i = 0; i < sc->sc_omlen; i++)
2095 NCR_MSGS((" %02x", sc->sc_omess[i]));
2096 NCR_MSGS(("> "));
2097 }
2098#endif
2099 if (sc->sc_rev == NCR_VARIANT_FAS366) {
2100 /*
2101 * XXX fifo size
2102 */
2103 ncr53c9x_flushfifo(sc);
2104 ncr53c9x_wrfifo(sc, sc->sc_omp, sc->sc_omlen);
2105 NCRCMD(sc, NCRCMD_TRANS);
2106 } else {
2107 /* (re)send the message */
2108 size = min(sc->sc_omlen, sc->sc_maxxfer);
2109 NCRDMA_SETUP(sc, &sc->sc_omp, &sc->sc_omlen, 0, &size);
2110 /* Program the SCSI counter */
2111 NCR_SET_COUNT(sc, size);
2112
2113 /* Load the count in and start the message-out transfer */
2114 NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
2115 NCRCMD(sc, NCRCMD_TRANS|NCRCMD_DMA);
2116 NCRDMA_GO(sc);
2117 }
2118}
2119
2120/*
2121 * This is the most critical part of the driver, and has to know
2122 * how to deal with *all* error conditions and phases from the SCSI
2123 * bus. If there are no errors and the DMA was active, then call the
2124 * DMA pseudo-interrupt handler. If this returns 1, then that was it
2125 * and we can return from here without further processing.
2126 *
2127 * Most of this needs verifying.
2128 */
2129void
2130ncr53c9x_intr(void *arg)
2131{
2132 struct ncr53c9x_softc *sc = arg;
2133 struct ncr53c9x_ecb *ecb;
2134 struct ncr53c9x_tinfo *ti;
2135 size_t size;
2136 int nfifo;
2137
2138 NCR_INTS(("[ncr53c9x_intr: state %d]", sc->sc_state));
2139
2140 if (!NCRDMA_ISINTR(sc))
2141 return;
2142
2143 mtx_lock(&sc->sc_lock);
2144again:
2145 /* and what do the registers say... */
2146 ncr53c9x_readregs(sc);
2147
2148 /*
2149 * At the moment, only a SCSI Bus Reset or Illegal
2150 * Command are classed as errors. A disconnect is a
2151 * valid condition, and we let the code check is the
2152 * "NCR_BUSFREE_OK" flag was set before declaring it
2153 * and error.
2154 *
2155 * Also, the status register tells us about "Gross
2156 * Errors" and "Parity errors". Only the Gross Error
2157 * is really bad, and the parity errors are dealt
2158 * with later
2159 *
2160 * TODO
2161 * If there are too many parity error, go to slow
2162 * cable mode ?
2163 */
2164
2165 /* SCSI Reset */
2166 if ((sc->sc_espintr & NCRINTR_SBR) != 0) {
2167 if ((NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) != 0) {
2168 NCRCMD(sc, NCRCMD_FLUSH);
2169 DELAY(1);
2170 }
2171 if (sc->sc_state != NCR_SBR) {
2172 device_printf(sc->sc_dev, "SCSI bus reset\n");
2173 ncr53c9x_init(sc, 0); /* Restart everything */
2174 goto out;
2175 }
2176#if 0
2177/*XXX*/ printf("<expected bus reset: "
2178 "[intr %x, stat %x, step %d]>\n",
2179 sc->sc_espintr, sc->sc_espstat, sc->sc_espstep);
2180#endif
2181 if (sc->sc_nexus != NULL)
2182 panic("%s: nexus in reset state",
2183 device_get_nameunit(sc->sc_dev));
2184 goto sched;
2185 }
2186
2187 ecb = sc->sc_nexus;
2188
2189#define NCRINTR_ERR (NCRINTR_SBR|NCRINTR_ILL)
2190 if (sc->sc_espintr & NCRINTR_ERR ||
2191 sc->sc_espstat & NCRSTAT_GE) {
2192
2193 if ((sc->sc_espstat & NCRSTAT_GE) != 0) {
2194 /* Gross Error; no target ? */
2195 if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
2196 NCRCMD(sc, NCRCMD_FLUSH);
2197 DELAY(1);
2198 }
2199 if (sc->sc_state == NCR_CONNECTED ||
2200 sc->sc_state == NCR_SELECTING) {
2201 ecb->ccb->ccb_h.status = CAM_SEL_TIMEOUT;
2202 ncr53c9x_done(sc, ecb);
2203 }
2204 goto out;
2205 }
2206
2207 if ((sc->sc_espintr & NCRINTR_ILL) != 0) {
2208 if ((sc->sc_flags & NCR_EXPECT_ILLCMD) != 0) {
2209 /*
2210 * Eat away "Illegal command" interrupt
2211 * on a ESP100 caused by a re-selection
2212 * while we were trying to select
2213 * another target.
2214 */
2215#ifdef DEBUG
2216 device_printf(sc->sc_dev, "ESP100 work-around "
2217 "activated\n");
2218#endif
2219 sc->sc_flags &= ~NCR_EXPECT_ILLCMD;
2220 goto out;
2221 }
2222 /* illegal command, out of sync ? */
2223 device_printf(sc->sc_dev, "illegal command: 0x%x "
2224 "(state %d, phase %x, prevphase %x)\n",
2225 sc->sc_lastcmd,
2226 sc->sc_state, sc->sc_phase, sc->sc_prevphase);
2227 if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
2228 NCRCMD(sc, NCRCMD_FLUSH);
2229 DELAY(1);
2230 }
2231 ncr53c9x_init(sc, 1); /* Restart everything */
2232 goto out;
2233 }
2234 }
2235 sc->sc_flags &= ~NCR_EXPECT_ILLCMD;
2236
2237 /*
2238 * Call if DMA is active.
2239 *
2240 * If DMA_INTR returns true, then maybe go 'round the loop
2241 * again in case there is no more DMA queued, but a phase
2242 * change is expected.
2243 */
2244 if (NCRDMA_ISACTIVE(sc)) {
2245 int r = NCRDMA_INTR(sc);
2246 if (r == -1) {
2247 device_printf(sc->sc_dev, "DMA error; resetting\n");
2248 ncr53c9x_init(sc, 1);
2249 goto out;
2250 }
2251 /* If DMA active here, then go back to work... */
2252 if (NCRDMA_ISACTIVE(sc))
2253 goto out;
2254
2255 if ((sc->sc_espstat & NCRSTAT_TC) == 0) {
2256 /*
2257 * DMA not completed. If we can not find a
2258 * acceptable explanation, print a diagnostic.
2259 */
2260 if (sc->sc_state == NCR_SELECTING)
2261 /*
2262 * This can happen if we are reselected
2263 * while using DMA to select a target.
2264 */
2265 /*void*/;
2266 else if (sc->sc_prevphase == MESSAGE_OUT_PHASE) {
2267 /*
2268 * Our (multi-byte) message (eg SDTR) was
2269 * interrupted by the target to send
2270 * a MSG REJECT.
2271 * Print diagnostic if current phase
2272 * is not MESSAGE IN.
2273 */
2274 if (sc->sc_phase != MESSAGE_IN_PHASE)
2275 device_printf(sc->sc_dev,"!TC on MSGOUT"
2276 " [intr %x, stat %x, step %d]"
2277 " prevphase %x, resid %lx\n",
2278 sc->sc_espintr,
2279 sc->sc_espstat,
2280 sc->sc_espstep,
2281 sc->sc_prevphase,
2282 (u_long)sc->sc_omlen);
2283 } else if (sc->sc_dleft == 0) {
2284 /*
2285 * The DMA operation was started for
2286 * a DATA transfer. Print a diagnostic
2287 * if the DMA counter and TC bit
2288 * appear to be out of sync.
2289 *
2290 * XXX This is fatal and usually means that
2291 * the DMA engine is hopelessly out of
2292 * sync with reality. A disk is likely
2293 * getting spammed at this point.
2294 */
2295 device_printf(sc->sc_dev, "!TC on DATA XFER"
2296 " [intr %x, stat %x, step %d]"
2297 " prevphase %x, resid %x\n",
2298 sc->sc_espintr,
2299 sc->sc_espstat,
2300 sc->sc_espstep,
2301 sc->sc_prevphase,
2302 ecb ? ecb->dleft : -1);
2303 panic("esp: unrecoverable DMA error");
2304 }
2305 }
2306 }
2307
2308 /*
2309 * Check for less serious errors.
2310 */
2311 if ((sc->sc_espstat & NCRSTAT_PE) != 0) {
2312 device_printf(sc->sc_dev, "SCSI bus parity error\n");
2313 if (sc->sc_prevphase == MESSAGE_IN_PHASE)
2314 ncr53c9x_sched_msgout(SEND_PARITY_ERROR);
2315 else
2316 ncr53c9x_sched_msgout(SEND_INIT_DET_ERR);
2317 }
2318
2319 if ((sc->sc_espintr & NCRINTR_DIS) != 0) {
2320 sc->sc_msgify = 0;
2321 NCR_INTS(("<DISC [intr %x, stat %x, step %d]>",
2322 sc->sc_espintr,sc->sc_espstat,sc->sc_espstep));
2323 if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
2324 NCRCMD(sc, NCRCMD_FLUSH);
2325/* DELAY(1); */
2326 }
2327 /*
2328 * This command must (apparently) be issued within
2329 * 250mS of a disconnect. So here you are...
2330 */
2331 NCRCMD(sc, NCRCMD_ENSEL);
2332
2333 switch (sc->sc_state) {
2334 case NCR_RESELECTED:
2335 goto sched;
2336
2337 case NCR_SELECTING:
2338 {
2339 struct ncr53c9x_linfo *li;
2340
2341 ecb->ccb->ccb_h.status = CAM_SEL_TIMEOUT;
2342
2343 /* Selection timeout -- discard all LUNs if empty */
2344 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
2345 li = LIST_FIRST(&ti->luns);
2346 while (li != NULL) {
2347 if (li->untagged == NULL && li->used == 0) {
2348 if (li->lun < NCR_NLUN)
2349 ti->lun[li->lun] = NULL;
2350 LIST_REMOVE(li, link);
2351 free(li, M_DEVBUF);
2352 /*
2353 * Restart the search at the beginning
2354 */
2355 li = LIST_FIRST(&ti->luns);
2356 continue;
2357 }
2358 li = LIST_NEXT(li, link);
2359 }
2360 goto finish;
2361 }
2362 case NCR_CONNECTED:
2363 if ((sc->sc_flags & NCR_SYNCHNEGO) != 0) {
2364#ifdef NCR53C9X_DEBUG
2365 if (ecb != NULL)
2366 xpt_print_path(ecb->ccb->ccb_h.path);
2367 printf("sync nego not completed!\n");
2368#endif
2369 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
2370 sc->sc_flags &= ~NCR_SYNCHNEGO;
2371 ti->flags &= ~(T_NEGOTIATE | T_SYNCMODE);
2372 }
2373
2374 /* it may be OK to disconnect */
2375 if ((sc->sc_flags & NCR_ABORTING) == 0) {
2376 /*
2377 * Section 5.1.1 of the SCSI 2 spec
2378 * suggests issuing a REQUEST SENSE
2379 * following an unexpected disconnect.
2380 * Some devices go into a contingent
2381 * allegiance condition when
2382 * disconnecting, and this is necessary
2383 * to clean up their state.
2384 */
2385 device_printf(sc->sc_dev, "unexpected "
2386 "disconnect [state %d, intr %x, stat %x, "
2387 "phase(c %x, p %x)]; ", sc->sc_state,
2388 sc->sc_espintr, sc->sc_espstat,
2389 sc->sc_phase, sc->sc_prevphase);
2390
2391 /*
2392 * XXX This will cause a chip reset and will
2393 * prevent us from finding out the real
2394 * problem with the device. However, it's
2395 * neccessary until a way can be found to
2396 * safely cancel the DMA that is in
2397 * progress.
2398 */
2399 if (1 || (ecb->flags & ECB_SENSE) != 0) {
2400 printf("resetting\n");
2401 goto reset;
2402 }
2403 printf("sending REQUEST SENSE\n");
2404 untimeout(ncr53c9x_timeout, ecb,
2405 ecb->ccb->ccb_h.timeout_ch);
2406 ncr53c9x_sense(sc, ecb);
2407 goto out;
2408 }
2409
2410 ecb->ccb->ccb_h.status = CAM_CMD_TIMEOUT;
2411 goto finish;
2412
2413 case NCR_DISCONNECT:
2414 sc->sc_nexus = NULL;
2415 goto sched;
2416
2417 case NCR_CMDCOMPLETE:
2418 ecb->ccb->ccb_h.status = CAM_REQ_CMP;
2419 goto finish;
2420 }
2421 }
2422
2423 switch (sc->sc_state) {
2424
2425 case NCR_SBR:
2426 device_printf(sc->sc_dev, "waiting for Bus Reset to happen\n");
2427 goto out;
2428
2429 case NCR_RESELECTED:
2430 /*
2431 * we must be continuing a message ?
2432 */
2433 device_printf(sc->sc_dev, "unhandled reselect continuation, "
2434 "state %d, intr %02x\n", sc->sc_state, sc->sc_espintr);
2435 ncr53c9x_init(sc, 1);
2436 goto out;
2437 break;
2438
2439 case NCR_IDENTIFIED:
2440 ecb = sc->sc_nexus;
2441 if (sc->sc_phase != MESSAGE_IN_PHASE) {
2442 int i = (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF);
2443 /*
2444 * Things are seriously screwed up.
2445 * Pull the brakes, i.e. reset
2446 */
2447 device_printf(sc->sc_dev, "target didn't send tag: %d "
2448 "bytes in fifo\n", i);
2449 /* Drain and display fifo */
2450 while (i-- > 0)
2451 printf("[%d] ", NCR_READ_REG(sc, NCR_FIFO));
2452
2453 ncr53c9x_init(sc, 1);
2454 goto out;
2455 } else
2456 goto msgin;
2457
2458 case NCR_IDLE:
2459 case NCR_SELECTING:
2460 ecb = sc->sc_nexus;
2461 if (sc->sc_espintr & NCRINTR_RESEL) {
2462 sc->sc_msgpriq = sc->sc_msgout = sc->sc_msgoutq = 0;
2463 sc->sc_flags = 0;
2464 /*
2465 * If we're trying to select a
2466 * target ourselves, push our command
2467 * back into the ready list.
2468 */
2469 if (sc->sc_state == NCR_SELECTING) {
2470 NCR_INTS(("backoff selector "));
2471 untimeout(ncr53c9x_timeout, ecb,
2472 ecb->ccb->ccb_h.timeout_ch);
2473 ncr53c9x_dequeue(sc, ecb);
2474 TAILQ_INSERT_HEAD(&sc->ready_list, ecb, chain);
2475 ecb->flags |= ECB_READY;
2476 ecb = sc->sc_nexus = NULL;
2477 }
2478 sc->sc_state = NCR_RESELECTED;
2479 if (sc->sc_phase != MESSAGE_IN_PHASE) {
2480 /*
2481 * Things are seriously screwed up.
2482 * Pull the brakes, i.e. reset
2483 */
2484 device_printf(sc->sc_dev, "target didn't "
2485 "identify\n");
2486 ncr53c9x_init(sc, 1);
2487 goto out;
2488 }
2489 /*
2490 * The C90 only inhibits FIFO writes until reselection
2491 * is complete instead of waiting until the interrupt
2492 * status register has been read. So, if the reselect
2493 * happens while we were entering command bytes (for
2494 * another target) some of those bytes can appear in
2495 * the FIFO here, after the interrupt is taken.
2496 *
2497 * To remedy this situation, pull the Selection ID
2498 * and Identify message from the FIFO directly, and
2499 * ignore any extraneous fifo contents. Also, set
2500 * a flag that allows one Illegal Command Interrupt
2501 * to occur which the chip also generates as a result
2502 * of writing to the FIFO during a reselect.
2503 */
2504 if (sc->sc_rev == NCR_VARIANT_ESP100) {
2505 nfifo = NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF;
2506 sc->sc_imess[0] = NCR_READ_REG(sc, NCR_FIFO);
2507 sc->sc_imess[1] = NCR_READ_REG(sc, NCR_FIFO);
2508 sc->sc_imlen = 2;
2509 if (nfifo != 2) {
2510 /* Flush the rest */
2511 NCRCMD(sc, NCRCMD_FLUSH);
2512 }
2513 sc->sc_flags |= NCR_EXPECT_ILLCMD;
2514 if (nfifo > 2)
2515 nfifo = 2; /* We fixed it.. */
2516 } else
2517 nfifo = ncr53c9x_rdfifo(sc, NCR_RDFIFO_START);
2518
2519 if (nfifo != 2) {
2520 device_printf(sc->sc_dev, "RESELECT: %d bytes "
2521 "in FIFO! [intr %x, stat %x, step %d, "
2522 "prevphase %x]\n",
2523 nfifo,
2524 sc->sc_espintr,
2525 sc->sc_espstat,
2526 sc->sc_espstep,
2527 sc->sc_prevphase);
2528 ncr53c9x_init(sc, 1);
2529 goto out;
2530 }
2531 sc->sc_selid = sc->sc_imess[0];
2532 NCR_INTS(("selid=%02x ", sc->sc_selid));
2533
2534 /* Handle identify message */
2535 ncr53c9x_msgin(sc);
2536
2537 if (sc->sc_state != NCR_CONNECTED &&
2538 sc->sc_state != NCR_IDENTIFIED) {
2539 /* IDENTIFY fail?! */
2540 device_printf(sc->sc_dev, "identify failed, "
2541 "state %d, intr %02x\n", sc->sc_state,
2542 sc->sc_espintr);
2543 ncr53c9x_init(sc, 1);
2544 goto out;
2545 }
2546 goto shortcut; /* ie. next phase expected soon */
2547 }
2548
2549#define NCRINTR_DONE (NCRINTR_FC|NCRINTR_BS)
2550 if ((sc->sc_espintr & NCRINTR_DONE) == NCRINTR_DONE) {
2551 /*
2552 * Arbitration won; examine the `step' register
2553 * to determine how far the selection could progress.
2554 */
|
2497 ecb = sc->sc_nexus;
2498 if (ecb == NULL)
| 2555 if (ecb == NULL) {
2556 /*
2557 * When doing path inquiry during boot
2558 * FAS100A trigger a stray interrupt which
2559 * we just ignore instead of panicing.
2560 */
2561 if (sc->sc_state == NCR_IDLE &&
2562 sc->sc_espstep == 0)
2563 goto out;
|
2499 panic("ncr53c9x: no nexus");
| 2564 panic("ncr53c9x: no nexus");
|
| 2565 }
|
2500
2501 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
2502
2503 switch (sc->sc_espstep) {
2504 case 0:
2505 /*
2506 * The target did not respond with a
2507 * message out phase - probably an old
2508 * device that doesn't recognize ATN.
2509 * Clear ATN and just continue, the
2510 * target should be in the command
2511 * phase.
2512 * XXXX check for command phase?
2513 */
2514 NCRCMD(sc, NCRCMD_RSTATN);
2515 break;
2516 case 1:
2517 if ((ti->flags & T_NEGOTIATE) == 0 &&
2518 ecb->tag[0] == 0) {
2519 device_printf(sc->sc_dev, "step 1 & "
2520 "!NEG\n");
2521 goto reset;
2522 }
2523 if (sc->sc_phase != MESSAGE_OUT_PHASE) {
2524 device_printf(sc->sc_dev, "!MSGOUT\n");
2525 goto reset;
2526 }
2527 if (ti->flags & T_WIDE) {
2528 ti->flags |= T_WDTRSENT;
2529 ncr53c9x_sched_msgout(SEND_WDTR);
2530 }
2531 if (ti->flags & T_NEGOTIATE) {
2532 /* Start negotiating */
2533 sc->sc_flags |= NCR_SYNCHNEGO;
2534 if (ecb->tag[0])
2535 ncr53c9x_sched_msgout(
2536 SEND_TAG|SEND_SDTR);
2537 else
2538 ncr53c9x_sched_msgout(
2539 SEND_SDTR);
2540 } else {
2541 /* Could not do ATN3 so send TAG */
2542 ncr53c9x_sched_msgout(SEND_TAG);
2543 }
2544 sc->sc_prevphase = MESSAGE_OUT_PHASE; /* XXXX */
2545 break;
2546 case 3:
2547 /*
2548 * Grr, this is supposed to mean
2549 * "target left command phase prematurely".
2550 * It seems to happen regularly when
2551 * sync mode is on.
2552 * Look at FIFO to see if command went out.
2553 * (Timing problems?)
2554 */
2555 if (sc->sc_features & NCR_F_DMASELECT) {
2556 if (sc->sc_cmdlen == 0)
2557 /* Hope for the best.. */
2558 break;
2559 } else if ((NCR_READ_REG(sc, NCR_FFLAG)
2560 & NCRFIFO_FF) == 0) {
2561 /* Hope for the best.. */
2562 break;
2563 }
2564 printf("(%s:%d:%d): selection failed;"
2565 " %d left in FIFO "
2566 "[intr %x, stat %x, step %d]\n",
2567 device_get_nameunit(sc->sc_dev),
2568 ecb->ccb->ccb_h.target_id,
2569 ecb->ccb->ccb_h.target_lun,
2570 NCR_READ_REG(sc, NCR_FFLAG)
2571 & NCRFIFO_FF,
2572 sc->sc_espintr, sc->sc_espstat,
2573 sc->sc_espstep);
2574 NCRCMD(sc, NCRCMD_FLUSH);
2575 ncr53c9x_sched_msgout(SEND_ABORT);
2576 goto out;
2577 case 2:
2578 /* Select stuck at Command Phase */
2579 NCRCMD(sc, NCRCMD_FLUSH);
2580 break;
2581 case 4:
2582 if (sc->sc_features & NCR_F_DMASELECT &&
2583 sc->sc_cmdlen != 0)
2584 printf("(%s:%d:%d): select; "
2585 "%lu left in DMA buffer "
2586 "[intr %x, stat %x, step %d]\n",
2587 device_get_nameunit(sc->sc_dev),
2588 ecb->ccb->ccb_h.target_id,
2589 ecb->ccb->ccb_h.target_lun,
2590 (u_long)sc->sc_cmdlen,
2591 sc->sc_espintr,
2592 sc->sc_espstat,
2593 sc->sc_espstep);
2594 /* So far, everything went fine */
2595 break;
2596 }
2597
2598 sc->sc_prevphase = INVALID_PHASE; /* ?? */
2599 /* Do an implicit RESTORE POINTERS. */
2600 sc->sc_dp = ecb->daddr;
2601 sc->sc_dleft = ecb->dleft;
2602 sc->sc_state = NCR_CONNECTED;
2603 break;
2604
2605 } else {
2606
2607 device_printf(sc->sc_dev, "unexpected status after "
2608 "select: [intr %x, stat %x, step %x]\n",
2609 sc->sc_espintr, sc->sc_espstat, sc->sc_espstep);
2610 NCRCMD(sc, NCRCMD_FLUSH);
2611 DELAY(1);
2612 goto reset;
2613 }
2614 if (sc->sc_state == NCR_IDLE) {
2615 device_printf(sc->sc_dev, "stray interrupt\n");
| 2566
2567 ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
2568
2569 switch (sc->sc_espstep) {
2570 case 0:
2571 /*
2572 * The target did not respond with a
2573 * message out phase - probably an old
2574 * device that doesn't recognize ATN.
2575 * Clear ATN and just continue, the
2576 * target should be in the command
2577 * phase.
2578 * XXXX check for command phase?
2579 */
2580 NCRCMD(sc, NCRCMD_RSTATN);
2581 break;
2582 case 1:
2583 if ((ti->flags & T_NEGOTIATE) == 0 &&
2584 ecb->tag[0] == 0) {
2585 device_printf(sc->sc_dev, "step 1 & "
2586 "!NEG\n");
2587 goto reset;
2588 }
2589 if (sc->sc_phase != MESSAGE_OUT_PHASE) {
2590 device_printf(sc->sc_dev, "!MSGOUT\n");
2591 goto reset;
2592 }
2593 if (ti->flags & T_WIDE) {
2594 ti->flags |= T_WDTRSENT;
2595 ncr53c9x_sched_msgout(SEND_WDTR);
2596 }
2597 if (ti->flags & T_NEGOTIATE) {
2598 /* Start negotiating */
2599 sc->sc_flags |= NCR_SYNCHNEGO;
2600 if (ecb->tag[0])
2601 ncr53c9x_sched_msgout(
2602 SEND_TAG|SEND_SDTR);
2603 else
2604 ncr53c9x_sched_msgout(
2605 SEND_SDTR);
2606 } else {
2607 /* Could not do ATN3 so send TAG */
2608 ncr53c9x_sched_msgout(SEND_TAG);
2609 }
2610 sc->sc_prevphase = MESSAGE_OUT_PHASE; /* XXXX */
2611 break;
2612 case 3:
2613 /*
2614 * Grr, this is supposed to mean
2615 * "target left command phase prematurely".
2616 * It seems to happen regularly when
2617 * sync mode is on.
2618 * Look at FIFO to see if command went out.
2619 * (Timing problems?)
2620 */
2621 if (sc->sc_features & NCR_F_DMASELECT) {
2622 if (sc->sc_cmdlen == 0)
2623 /* Hope for the best.. */
2624 break;
2625 } else if ((NCR_READ_REG(sc, NCR_FFLAG)
2626 & NCRFIFO_FF) == 0) {
2627 /* Hope for the best.. */
2628 break;
2629 }
2630 printf("(%s:%d:%d): selection failed;"
2631 " %d left in FIFO "
2632 "[intr %x, stat %x, step %d]\n",
2633 device_get_nameunit(sc->sc_dev),
2634 ecb->ccb->ccb_h.target_id,
2635 ecb->ccb->ccb_h.target_lun,
2636 NCR_READ_REG(sc, NCR_FFLAG)
2637 & NCRFIFO_FF,
2638 sc->sc_espintr, sc->sc_espstat,
2639 sc->sc_espstep);
2640 NCRCMD(sc, NCRCMD_FLUSH);
2641 ncr53c9x_sched_msgout(SEND_ABORT);
2642 goto out;
2643 case 2:
2644 /* Select stuck at Command Phase */
2645 NCRCMD(sc, NCRCMD_FLUSH);
2646 break;
2647 case 4:
2648 if (sc->sc_features & NCR_F_DMASELECT &&
2649 sc->sc_cmdlen != 0)
2650 printf("(%s:%d:%d): select; "
2651 "%lu left in DMA buffer "
2652 "[intr %x, stat %x, step %d]\n",
2653 device_get_nameunit(sc->sc_dev),
2654 ecb->ccb->ccb_h.target_id,
2655 ecb->ccb->ccb_h.target_lun,
2656 (u_long)sc->sc_cmdlen,
2657 sc->sc_espintr,
2658 sc->sc_espstat,
2659 sc->sc_espstep);
2660 /* So far, everything went fine */
2661 break;
2662 }
2663
2664 sc->sc_prevphase = INVALID_PHASE; /* ?? */
2665 /* Do an implicit RESTORE POINTERS. */
2666 sc->sc_dp = ecb->daddr;
2667 sc->sc_dleft = ecb->dleft;
2668 sc->sc_state = NCR_CONNECTED;
2669 break;
2670
2671 } else {
2672
2673 device_printf(sc->sc_dev, "unexpected status after "
2674 "select: [intr %x, stat %x, step %x]\n",
2675 sc->sc_espintr, sc->sc_espstat, sc->sc_espstep);
2676 NCRCMD(sc, NCRCMD_FLUSH);
2677 DELAY(1);
2678 goto reset;
2679 }
2680 if (sc->sc_state == NCR_IDLE) {
2681 device_printf(sc->sc_dev, "stray interrupt\n");
|
2616 mtx_unlock(&sc->sc_lock);
2617 return;
| 2682 goto out;
|
2618 }
2619 break;
2620
2621 case NCR_CONNECTED:
2622 if ((sc->sc_flags & NCR_ICCS) != 0) {
2623 /* "Initiate Command Complete Steps" in progress */
2624 u_char msg;
2625
2626 sc->sc_flags &= ~NCR_ICCS;
2627
2628 if (!(sc->sc_espintr & NCRINTR_DONE)) {
2629 device_printf(sc->sc_dev, "ICCS: "
2630 ": [intr %x, stat %x, step %x]\n",
2631 sc->sc_espintr, sc->sc_espstat,
2632 sc->sc_espstep);
2633 }
2634 ncr53c9x_rdfifo(sc, NCR_RDFIFO_START);
2635 if (sc->sc_imlen < 2)
2636 device_printf(sc->sc_dev, "can't get status, "
2637 "only %d bytes\n", (int)sc->sc_imlen);
2638 ecb->stat = sc->sc_imess[sc->sc_imlen - 2];
2639 msg = sc->sc_imess[sc->sc_imlen - 1];
2640 NCR_PHASE(("<stat:(%x,%x)>", ecb->stat, msg));
2641 if (msg == MSG_CMDCOMPLETE) {
2642 ecb->dleft = (ecb->flags & ECB_TENTATIVE_DONE)
2643 ? 0 : sc->sc_dleft;
2644 if ((ecb->flags & ECB_SENSE) == 0)
2645 ecb->ccb->csio.resid = ecb->dleft;
2646 sc->sc_state = NCR_CMDCOMPLETE;
2647 } else
2648 device_printf(sc->sc_dev, "STATUS_PHASE: "
2649 "msg %d\n", msg);
2650 sc->sc_imlen = 0;
2651 NCRCMD(sc, NCRCMD_MSGOK);
2652 goto shortcut; /* ie. wait for disconnect */
2653 }
2654 break;
2655
2656 default:
2657 device_printf(sc->sc_dev, "invalid state: %d [intr %x, "
2658 "phase(c %x, p %x)]\n", sc->sc_state,
2659 sc->sc_espintr, sc->sc_phase, sc->sc_prevphase);
2660 goto reset;
2661 }
2662
2663 /*
2664 * Driver is now in state NCR_CONNECTED, i.e. we
2665 * have a current command working the SCSI bus.
2666 */
2667 if (sc->sc_state != NCR_CONNECTED || ecb == NULL) {
2668 panic("ncr53c9x: no nexus");
2669 }
2670
2671 switch (sc->sc_phase) {
2672 case MESSAGE_OUT_PHASE:
2673 NCR_PHASE(("MESSAGE_OUT_PHASE "));
2674 ncr53c9x_msgout(sc);
2675 sc->sc_prevphase = MESSAGE_OUT_PHASE;
2676 break;
2677
2678 case MESSAGE_IN_PHASE:
2679msgin:
2680 NCR_PHASE(("MESSAGE_IN_PHASE "));
2681 if ((sc->sc_espintr & NCRINTR_BS) != 0) {
2682 if ((sc->sc_rev != NCR_VARIANT_FAS366) ||
2683 !(sc->sc_espstat2 & NCRFAS_STAT2_EMPTY)) {
2684 NCRCMD(sc, NCRCMD_FLUSH);
2685 }
2686 sc->sc_flags |= NCR_WAITI;
2687 NCRCMD(sc, NCRCMD_TRANS);
2688 } else if ((sc->sc_espintr & NCRINTR_FC) != 0) {
2689 if ((sc->sc_flags & NCR_WAITI) == 0) {
2690 device_printf(sc->sc_dev, "MSGIN: unexpected "
2691 "FC bit: [intr %x, stat %x, step %x]\n",
2692 sc->sc_espintr, sc->sc_espstat,
2693 sc->sc_espstep);
2694 }
2695 sc->sc_flags &= ~NCR_WAITI;
2696 ncr53c9x_rdfifo(sc,
2697 (sc->sc_prevphase == sc->sc_phase) ?
2698 NCR_RDFIFO_CONTINUE : NCR_RDFIFO_START);
2699 ncr53c9x_msgin(sc);
2700 } else {
2701 device_printf(sc->sc_dev, "MSGIN: weird bits: "
2702 "[intr %x, stat %x, step %x]\n",
2703 sc->sc_espintr, sc->sc_espstat, sc->sc_espstep);
2704 }
2705 sc->sc_prevphase = MESSAGE_IN_PHASE;
2706 goto shortcut; /* i.e. expect data to be ready */
2707
2708 case COMMAND_PHASE:
2709 /*
2710 * Send the command block. Normally we don't see this
2711 * phase because the SEL_ATN command takes care of
2712 * all this. However, we end up here if either the
2713 * target or we wanted to exchange some more messages
2714 * first (e.g. to start negotiations).
2715 */
2716
2717 NCR_PHASE(("COMMAND_PHASE 0x%02x (%d) ",
2718 ecb->cmd.cmd.opcode, ecb->clen));
2719 if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
2720 NCRCMD(sc, NCRCMD_FLUSH);
2721/* DELAY(1);*/
2722 }
2723 if (sc->sc_features & NCR_F_DMASELECT) {
2724 /* setup DMA transfer for command */
2725 size = ecb->clen;
2726 sc->sc_cmdlen = size;
2727 sc->sc_cmdp = (caddr_t)&ecb->cmd.cmd;
2728 NCRDMA_SETUP(sc, &sc->sc_cmdp, &sc->sc_cmdlen,
2729 0, &size);
2730 /* Program the SCSI counter */
2731 NCR_SET_COUNT(sc, size);
2732
2733 /* load the count in */
2734 NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
2735
2736 /* start the command transfer */
2737 NCRCMD(sc, NCRCMD_TRANS | NCRCMD_DMA);
2738 NCRDMA_GO(sc);
2739 } else {
2740 ncr53c9x_wrfifo(sc, (u_char *)&ecb->cmd.cmd, ecb->clen);
2741 NCRCMD(sc, NCRCMD_TRANS);
2742 }
2743 sc->sc_prevphase = COMMAND_PHASE;
2744 break;
2745
2746 case DATA_OUT_PHASE:
2747 NCR_PHASE(("DATA_OUT_PHASE [%ld] ",(long)sc->sc_dleft));
2748 NCRCMD(sc, NCRCMD_FLUSH);
2749 size = min(sc->sc_dleft, sc->sc_maxxfer);
2750 NCRDMA_SETUP(sc, &sc->sc_dp, &sc->sc_dleft, 0, &size);
2751 sc->sc_prevphase = DATA_OUT_PHASE;
2752 goto setup_xfer;
2753
2754 case DATA_IN_PHASE:
2755 NCR_PHASE(("DATA_IN_PHASE "));
2756 if (sc->sc_rev == NCR_VARIANT_ESP100)
2757 NCRCMD(sc, NCRCMD_FLUSH);
2758 size = min(sc->sc_dleft, sc->sc_maxxfer);
2759 NCRDMA_SETUP(sc, &sc->sc_dp, &sc->sc_dleft, 1, &size);
2760 sc->sc_prevphase = DATA_IN_PHASE;
2761 setup_xfer:
2762 /* Target returned to data phase: wipe "done" memory */
2763 ecb->flags &= ~ECB_TENTATIVE_DONE;
2764
2765 /* Program the SCSI counter */
2766 NCR_SET_COUNT(sc, size);
2767
2768 /* load the count in */
2769 NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
2770
2771 /*
2772 * Note that if `size' is 0, we've already transceived
2773 * all the bytes we want but we're still in DATA PHASE.
2774 * Apparently, the device needs padding. Also, a
2775 * transfer size of 0 means "maximum" to the chip
2776 * DMA logic.
2777 */
2778 NCRCMD(sc,
2779 (size == 0 ? NCRCMD_TRPAD : NCRCMD_TRANS) | NCRCMD_DMA);
2780 NCRDMA_GO(sc);
2781 goto out;
2782
2783 case STATUS_PHASE:
2784 NCR_PHASE(("STATUS_PHASE "));
2785 sc->sc_flags |= NCR_ICCS;
2786 NCRCMD(sc, NCRCMD_ICCS);
2787 sc->sc_prevphase = STATUS_PHASE;
2788 goto shortcut; /* i.e. expect status results soon */
2789
2790 case INVALID_PHASE:
2791 break;
2792
2793 default:
2794 device_printf(sc->sc_dev, "unexpected bus phase; resetting\n");
2795 goto reset;
2796 }
2797
2798out:
2799 mtx_unlock(&sc->sc_lock);
2800 return;
2801
2802reset:
2803 ncr53c9x_init(sc, 1);
2804 goto out;
2805
2806finish:
2807 ncr53c9x_done(sc, ecb);
2808 goto out;
2809
2810sched:
2811 sc->sc_state = NCR_IDLE;
2812 ncr53c9x_sched(sc);
2813 goto out;
2814
2815shortcut:
2816 /*
2817 * The idea is that many of the SCSI operations take very little
2818 * time, and going away and getting interrupted is too high an
2819 * overhead to pay. For example, selecting, sending a message
2820 * and command and then doing some work can be done in one "pass".
2821 *
2822 * The delay is a heuristic. It is 2 when at 20MHz, 2 at 25MHz and 1
2823 * at 40MHz. This needs testing.
2824 */
2825 {
2826 struct timeval wait, cur;
2827
2828 microtime(&wait);
2829 wait.tv_usec += 50 / sc->sc_freq;
2830 if (wait.tv_usec > 1000000) {
2831 wait.tv_sec++;
2832 wait.tv_usec -= 1000000;
2833 }
2834 do {
2835 if (NCRDMA_ISINTR(sc))
2836 goto again;
2837 microtime(&cur);
2838 } while (cur.tv_sec <= wait.tv_sec &&
2839 cur.tv_usec <= wait.tv_usec);
2840 }
2841 goto out;
2842}
2843
2844static void
2845ncr53c9x_abort(sc, ecb)
2846 struct ncr53c9x_softc *sc;
2847 struct ncr53c9x_ecb *ecb;
2848{
2849
2850 /* 2 secs for the abort */
2851 ecb->timeout = NCR_ABORT_TIMEOUT;
2852 ecb->flags |= ECB_ABORT;
2853
2854 if (ecb == sc->sc_nexus) {
2855 /*
2856 * If we're still selecting, the message will be scheduled
2857 * after selection is complete.
2858 */
2859 if (sc->sc_state == NCR_CONNECTED)
2860 ncr53c9x_sched_msgout(SEND_ABORT);
2861
2862 /*
2863 * Reschedule timeout.
2864 */
2865 ecb->ccb->ccb_h.timeout_ch =
2866 timeout(ncr53c9x_timeout, ecb, mstohz(ecb->timeout));
2867 } else {
2868 /*
2869 * Just leave the command where it is.
2870 * XXX - what choice do we have but to reset the SCSI
2871 * eventually?
2872 */
2873 if (sc->sc_state == NCR_IDLE)
2874 ncr53c9x_sched(sc);
2875 }
2876}
2877
2878static void
2879ncr53c9x_timeout(void *arg)
2880{
2881 struct ncr53c9x_ecb *ecb = arg;
2882 union ccb *ccb = ecb->ccb;
2883 struct ncr53c9x_softc *sc = ecb->sc;
2884 struct ncr53c9x_tinfo *ti = &sc->sc_tinfo[ccb->ccb_h.target_id];
2885
2886 xpt_print_path(ccb->ccb_h.path);
2887 device_printf(sc->sc_dev, "timed out [ecb %p (flags 0x%x, dleft %x, "
2888 "stat %x)], <state %d, nexus %p, phase(l %x, c %x, p %x), "
2889 "resid %lx, msg(q %x,o %x) %s>",
2890 ecb, ecb->flags, ecb->dleft, ecb->stat,
2891 sc->sc_state, sc->sc_nexus,
2892 NCR_READ_REG(sc, NCR_STAT),
2893 sc->sc_phase, sc->sc_prevphase,
2894 (long)sc->sc_dleft, sc->sc_msgpriq, sc->sc_msgout,
2895 NCRDMA_ISACTIVE(sc) ? "DMA active" : "");
2896#if NCR53C9X_DEBUG > 1
2897 printf("TRACE: %s.", ecb->trace);
2898#endif
2899
2900 mtx_lock(&sc->sc_lock);
2901
2902 if (ecb->flags & ECB_ABORT) {
2903 /* abort timed out */
2904 printf(" AGAIN\n");
2905
2906 ncr53c9x_init(sc, 1);
2907 } else {
2908 /* abort the operation that has timed out */
2909 printf("\n");
2910 ccb->ccb_h.status = CAM_CMD_TIMEOUT;
2911 ncr53c9x_abort(sc, ecb);
2912
2913 /* Disable sync mode if stuck in a data phase */
2914 if (ecb == sc->sc_nexus &&
2915 (ti->flags & T_SYNCMODE) != 0 &&
2916 (sc->sc_phase & (MSGI|CDI)) == 0) {
2917 /* XXX ASYNC CALLBACK! */
2918 xpt_print_path(ccb->ccb_h.path);
2919 printf("sync negotiation disabled\n");
2920 sc->sc_cfflags |=
2921 (1 << ((ccb->ccb_h.target_id & 7) + 8));
2922 }
2923 }
2924
2925 mtx_unlock(&sc->sc_lock);
2926}
2927
2928static void
2929ncr53c9x_watch(void *arg)
2930{
2931 struct ncr53c9x_softc *sc = (struct ncr53c9x_softc *)arg;
2932 struct ncr53c9x_tinfo *ti;
2933 struct ncr53c9x_linfo *li;
2934 int t;
2935 /* Delete any structures that have not been used in 10min. */
2936 time_t old = time_second - (10 * 60);
2937
2938 mtx_lock(&sc->sc_lock);
2939 for (t = 0; t < sc->sc_ntarg; t++) {
2940 ti = &sc->sc_tinfo[t];
2941 li = LIST_FIRST(&ti->luns);
2942 while (li) {
2943 if (li->last_used < old &&
2944 li->untagged == NULL &&
2945 li->used == 0) {
2946 if (li->lun < NCR_NLUN)
2947 ti->lun[li->lun] = NULL;
2948 LIST_REMOVE(li, link);
2949 free(li, M_DEVBUF);
2950 /* Restart the search at the beginning */
2951 li = LIST_FIRST(&ti->luns);
2952 continue;
2953 }
2954 li = LIST_NEXT(li, link);
2955 }
2956 }
2957 mtx_unlock(&sc->sc_lock);
2958 callout_reset(&sc->sc_watchdog, 60 * hz, ncr53c9x_watch, sc);
2959}
| 2683 }
2684 break;
2685
2686 case NCR_CONNECTED:
2687 if ((sc->sc_flags & NCR_ICCS) != 0) {
2688 /* "Initiate Command Complete Steps" in progress */
2689 u_char msg;
2690
2691 sc->sc_flags &= ~NCR_ICCS;
2692
2693 if (!(sc->sc_espintr & NCRINTR_DONE)) {
2694 device_printf(sc->sc_dev, "ICCS: "
2695 ": [intr %x, stat %x, step %x]\n",
2696 sc->sc_espintr, sc->sc_espstat,
2697 sc->sc_espstep);
2698 }
2699 ncr53c9x_rdfifo(sc, NCR_RDFIFO_START);
2700 if (sc->sc_imlen < 2)
2701 device_printf(sc->sc_dev, "can't get status, "
2702 "only %d bytes\n", (int)sc->sc_imlen);
2703 ecb->stat = sc->sc_imess[sc->sc_imlen - 2];
2704 msg = sc->sc_imess[sc->sc_imlen - 1];
2705 NCR_PHASE(("<stat:(%x,%x)>", ecb->stat, msg));
2706 if (msg == MSG_CMDCOMPLETE) {
2707 ecb->dleft = (ecb->flags & ECB_TENTATIVE_DONE)
2708 ? 0 : sc->sc_dleft;
2709 if ((ecb->flags & ECB_SENSE) == 0)
2710 ecb->ccb->csio.resid = ecb->dleft;
2711 sc->sc_state = NCR_CMDCOMPLETE;
2712 } else
2713 device_printf(sc->sc_dev, "STATUS_PHASE: "
2714 "msg %d\n", msg);
2715 sc->sc_imlen = 0;
2716 NCRCMD(sc, NCRCMD_MSGOK);
2717 goto shortcut; /* ie. wait for disconnect */
2718 }
2719 break;
2720
2721 default:
2722 device_printf(sc->sc_dev, "invalid state: %d [intr %x, "
2723 "phase(c %x, p %x)]\n", sc->sc_state,
2724 sc->sc_espintr, sc->sc_phase, sc->sc_prevphase);
2725 goto reset;
2726 }
2727
2728 /*
2729 * Driver is now in state NCR_CONNECTED, i.e. we
2730 * have a current command working the SCSI bus.
2731 */
2732 if (sc->sc_state != NCR_CONNECTED || ecb == NULL) {
2733 panic("ncr53c9x: no nexus");
2734 }
2735
2736 switch (sc->sc_phase) {
2737 case MESSAGE_OUT_PHASE:
2738 NCR_PHASE(("MESSAGE_OUT_PHASE "));
2739 ncr53c9x_msgout(sc);
2740 sc->sc_prevphase = MESSAGE_OUT_PHASE;
2741 break;
2742
2743 case MESSAGE_IN_PHASE:
2744msgin:
2745 NCR_PHASE(("MESSAGE_IN_PHASE "));
2746 if ((sc->sc_espintr & NCRINTR_BS) != 0) {
2747 if ((sc->sc_rev != NCR_VARIANT_FAS366) ||
2748 !(sc->sc_espstat2 & NCRFAS_STAT2_EMPTY)) {
2749 NCRCMD(sc, NCRCMD_FLUSH);
2750 }
2751 sc->sc_flags |= NCR_WAITI;
2752 NCRCMD(sc, NCRCMD_TRANS);
2753 } else if ((sc->sc_espintr & NCRINTR_FC) != 0) {
2754 if ((sc->sc_flags & NCR_WAITI) == 0) {
2755 device_printf(sc->sc_dev, "MSGIN: unexpected "
2756 "FC bit: [intr %x, stat %x, step %x]\n",
2757 sc->sc_espintr, sc->sc_espstat,
2758 sc->sc_espstep);
2759 }
2760 sc->sc_flags &= ~NCR_WAITI;
2761 ncr53c9x_rdfifo(sc,
2762 (sc->sc_prevphase == sc->sc_phase) ?
2763 NCR_RDFIFO_CONTINUE : NCR_RDFIFO_START);
2764 ncr53c9x_msgin(sc);
2765 } else {
2766 device_printf(sc->sc_dev, "MSGIN: weird bits: "
2767 "[intr %x, stat %x, step %x]\n",
2768 sc->sc_espintr, sc->sc_espstat, sc->sc_espstep);
2769 }
2770 sc->sc_prevphase = MESSAGE_IN_PHASE;
2771 goto shortcut; /* i.e. expect data to be ready */
2772
2773 case COMMAND_PHASE:
2774 /*
2775 * Send the command block. Normally we don't see this
2776 * phase because the SEL_ATN command takes care of
2777 * all this. However, we end up here if either the
2778 * target or we wanted to exchange some more messages
2779 * first (e.g. to start negotiations).
2780 */
2781
2782 NCR_PHASE(("COMMAND_PHASE 0x%02x (%d) ",
2783 ecb->cmd.cmd.opcode, ecb->clen));
2784 if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
2785 NCRCMD(sc, NCRCMD_FLUSH);
2786/* DELAY(1);*/
2787 }
2788 if (sc->sc_features & NCR_F_DMASELECT) {
2789 /* setup DMA transfer for command */
2790 size = ecb->clen;
2791 sc->sc_cmdlen = size;
2792 sc->sc_cmdp = (caddr_t)&ecb->cmd.cmd;
2793 NCRDMA_SETUP(sc, &sc->sc_cmdp, &sc->sc_cmdlen,
2794 0, &size);
2795 /* Program the SCSI counter */
2796 NCR_SET_COUNT(sc, size);
2797
2798 /* load the count in */
2799 NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
2800
2801 /* start the command transfer */
2802 NCRCMD(sc, NCRCMD_TRANS | NCRCMD_DMA);
2803 NCRDMA_GO(sc);
2804 } else {
2805 ncr53c9x_wrfifo(sc, (u_char *)&ecb->cmd.cmd, ecb->clen);
2806 NCRCMD(sc, NCRCMD_TRANS);
2807 }
2808 sc->sc_prevphase = COMMAND_PHASE;
2809 break;
2810
2811 case DATA_OUT_PHASE:
2812 NCR_PHASE(("DATA_OUT_PHASE [%ld] ",(long)sc->sc_dleft));
2813 NCRCMD(sc, NCRCMD_FLUSH);
2814 size = min(sc->sc_dleft, sc->sc_maxxfer);
2815 NCRDMA_SETUP(sc, &sc->sc_dp, &sc->sc_dleft, 0, &size);
2816 sc->sc_prevphase = DATA_OUT_PHASE;
2817 goto setup_xfer;
2818
2819 case DATA_IN_PHASE:
2820 NCR_PHASE(("DATA_IN_PHASE "));
2821 if (sc->sc_rev == NCR_VARIANT_ESP100)
2822 NCRCMD(sc, NCRCMD_FLUSH);
2823 size = min(sc->sc_dleft, sc->sc_maxxfer);
2824 NCRDMA_SETUP(sc, &sc->sc_dp, &sc->sc_dleft, 1, &size);
2825 sc->sc_prevphase = DATA_IN_PHASE;
2826 setup_xfer:
2827 /* Target returned to data phase: wipe "done" memory */
2828 ecb->flags &= ~ECB_TENTATIVE_DONE;
2829
2830 /* Program the SCSI counter */
2831 NCR_SET_COUNT(sc, size);
2832
2833 /* load the count in */
2834 NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
2835
2836 /*
2837 * Note that if `size' is 0, we've already transceived
2838 * all the bytes we want but we're still in DATA PHASE.
2839 * Apparently, the device needs padding. Also, a
2840 * transfer size of 0 means "maximum" to the chip
2841 * DMA logic.
2842 */
2843 NCRCMD(sc,
2844 (size == 0 ? NCRCMD_TRPAD : NCRCMD_TRANS) | NCRCMD_DMA);
2845 NCRDMA_GO(sc);
2846 goto out;
2847
2848 case STATUS_PHASE:
2849 NCR_PHASE(("STATUS_PHASE "));
2850 sc->sc_flags |= NCR_ICCS;
2851 NCRCMD(sc, NCRCMD_ICCS);
2852 sc->sc_prevphase = STATUS_PHASE;
2853 goto shortcut; /* i.e. expect status results soon */
2854
2855 case INVALID_PHASE:
2856 break;
2857
2858 default:
2859 device_printf(sc->sc_dev, "unexpected bus phase; resetting\n");
2860 goto reset;
2861 }
2862
2863out:
2864 mtx_unlock(&sc->sc_lock);
2865 return;
2866
2867reset:
2868 ncr53c9x_init(sc, 1);
2869 goto out;
2870
2871finish:
2872 ncr53c9x_done(sc, ecb);
2873 goto out;
2874
2875sched:
2876 sc->sc_state = NCR_IDLE;
2877 ncr53c9x_sched(sc);
2878 goto out;
2879
2880shortcut:
2881 /*
2882 * The idea is that many of the SCSI operations take very little
2883 * time, and going away and getting interrupted is too high an
2884 * overhead to pay. For example, selecting, sending a message
2885 * and command and then doing some work can be done in one "pass".
2886 *
2887 * The delay is a heuristic. It is 2 when at 20MHz, 2 at 25MHz and 1
2888 * at 40MHz. This needs testing.
2889 */
2890 {
2891 struct timeval wait, cur;
2892
2893 microtime(&wait);
2894 wait.tv_usec += 50 / sc->sc_freq;
2895 if (wait.tv_usec > 1000000) {
2896 wait.tv_sec++;
2897 wait.tv_usec -= 1000000;
2898 }
2899 do {
2900 if (NCRDMA_ISINTR(sc))
2901 goto again;
2902 microtime(&cur);
2903 } while (cur.tv_sec <= wait.tv_sec &&
2904 cur.tv_usec <= wait.tv_usec);
2905 }
2906 goto out;
2907}
2908
2909static void
2910ncr53c9x_abort(sc, ecb)
2911 struct ncr53c9x_softc *sc;
2912 struct ncr53c9x_ecb *ecb;
2913{
2914
2915 /* 2 secs for the abort */
2916 ecb->timeout = NCR_ABORT_TIMEOUT;
2917 ecb->flags |= ECB_ABORT;
2918
2919 if (ecb == sc->sc_nexus) {
2920 /*
2921 * If we're still selecting, the message will be scheduled
2922 * after selection is complete.
2923 */
2924 if (sc->sc_state == NCR_CONNECTED)
2925 ncr53c9x_sched_msgout(SEND_ABORT);
2926
2927 /*
2928 * Reschedule timeout.
2929 */
2930 ecb->ccb->ccb_h.timeout_ch =
2931 timeout(ncr53c9x_timeout, ecb, mstohz(ecb->timeout));
2932 } else {
2933 /*
2934 * Just leave the command where it is.
2935 * XXX - what choice do we have but to reset the SCSI
2936 * eventually?
2937 */
2938 if (sc->sc_state == NCR_IDLE)
2939 ncr53c9x_sched(sc);
2940 }
2941}
2942
2943static void
2944ncr53c9x_timeout(void *arg)
2945{
2946 struct ncr53c9x_ecb *ecb = arg;
2947 union ccb *ccb = ecb->ccb;
2948 struct ncr53c9x_softc *sc = ecb->sc;
2949 struct ncr53c9x_tinfo *ti = &sc->sc_tinfo[ccb->ccb_h.target_id];
2950
2951 xpt_print_path(ccb->ccb_h.path);
2952 device_printf(sc->sc_dev, "timed out [ecb %p (flags 0x%x, dleft %x, "
2953 "stat %x)], <state %d, nexus %p, phase(l %x, c %x, p %x), "
2954 "resid %lx, msg(q %x,o %x) %s>",
2955 ecb, ecb->flags, ecb->dleft, ecb->stat,
2956 sc->sc_state, sc->sc_nexus,
2957 NCR_READ_REG(sc, NCR_STAT),
2958 sc->sc_phase, sc->sc_prevphase,
2959 (long)sc->sc_dleft, sc->sc_msgpriq, sc->sc_msgout,
2960 NCRDMA_ISACTIVE(sc) ? "DMA active" : "");
2961#if NCR53C9X_DEBUG > 1
2962 printf("TRACE: %s.", ecb->trace);
2963#endif
2964
2965 mtx_lock(&sc->sc_lock);
2966
2967 if (ecb->flags & ECB_ABORT) {
2968 /* abort timed out */
2969 printf(" AGAIN\n");
2970
2971 ncr53c9x_init(sc, 1);
2972 } else {
2973 /* abort the operation that has timed out */
2974 printf("\n");
2975 ccb->ccb_h.status = CAM_CMD_TIMEOUT;
2976 ncr53c9x_abort(sc, ecb);
2977
2978 /* Disable sync mode if stuck in a data phase */
2979 if (ecb == sc->sc_nexus &&
2980 (ti->flags & T_SYNCMODE) != 0 &&
2981 (sc->sc_phase & (MSGI|CDI)) == 0) {
2982 /* XXX ASYNC CALLBACK! */
2983 xpt_print_path(ccb->ccb_h.path);
2984 printf("sync negotiation disabled\n");
2985 sc->sc_cfflags |=
2986 (1 << ((ccb->ccb_h.target_id & 7) + 8));
2987 }
2988 }
2989
2990 mtx_unlock(&sc->sc_lock);
2991}
2992
2993static void
2994ncr53c9x_watch(void *arg)
2995{
2996 struct ncr53c9x_softc *sc = (struct ncr53c9x_softc *)arg;
2997 struct ncr53c9x_tinfo *ti;
2998 struct ncr53c9x_linfo *li;
2999 int t;
3000 /* Delete any structures that have not been used in 10min. */
3001 time_t old = time_second - (10 * 60);
3002
3003 mtx_lock(&sc->sc_lock);
3004 for (t = 0; t < sc->sc_ntarg; t++) {
3005 ti = &sc->sc_tinfo[t];
3006 li = LIST_FIRST(&ti->luns);
3007 while (li) {
3008 if (li->last_used < old &&
3009 li->untagged == NULL &&
3010 li->used == 0) {
3011 if (li->lun < NCR_NLUN)
3012 ti->lun[li->lun] = NULL;
3013 LIST_REMOVE(li, link);
3014 free(li, M_DEVBUF);
3015 /* Restart the search at the beginning */
3016 li = LIST_FIRST(&ti->luns);
3017 continue;
3018 }
3019 li = LIST_NEXT(li, link);
3020 }
3021 }
3022 mtx_unlock(&sc->sc_lock);
3023 callout_reset(&sc->sc_watchdog, 60 * hz, ncr53c9x_watch, sc);
3024}
|