isp.c revision 1.29 1 1.26 mjacob /* $NetBSD: isp.c,v 1.29 1998/12/28 19:10:43 mjacob Exp $ */
2 1.29 mjacob /* release_12_28_98_A */
3 1.1 cgd /*
4 1.25 mjacob * Machine and OS Independent (well, as best as possible)
5 1.1 cgd * code for the Qlogic ISP SCSI adapters.
6 1.1 cgd *
7 1.23 mjacob *---------------------------------------
8 1.23 mjacob * Copyright (c) 1997, 1998 by Matthew Jacob
9 1.23 mjacob * NASA/Ames Research Center
10 1.1 cgd * All rights reserved.
11 1.23 mjacob *---------------------------------------
12 1.1 cgd *
13 1.1 cgd * Redistribution and use in source and binary forms, with or without
14 1.1 cgd * modification, are permitted provided that the following conditions
15 1.1 cgd * are met:
16 1.1 cgd * 1. Redistributions of source code must retain the above copyright
17 1.1 cgd * notice immediately at the beginning of the file, without modification,
18 1.1 cgd * this list of conditions, and the following disclaimer.
19 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
20 1.1 cgd * notice, this list of conditions and the following disclaimer in the
21 1.1 cgd * documentation and/or other materials provided with the distribution.
22 1.1 cgd * 3. The name of the author may not be used to endorse or promote products
23 1.1 cgd * derived from this software without specific prior written permission.
24 1.1 cgd *
25 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
26 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
29 1.1 cgd * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 1.1 cgd * SUCH DAMAGE.
36 1.1 cgd */
37 1.2 cgd
38 1.1 cgd /*
39 1.1 cgd * Inspiration and ideas about this driver are from Erik Moe's Linux driver
40 1.23 mjacob * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
41 1.23 mjacob * ideas dredged from the Solaris driver.
42 1.1 cgd */
43 1.1 cgd
44 1.23 mjacob /*
45 1.23 mjacob * Include header file appropriate for platform we're building on.
46 1.23 mjacob */
47 1.1 cgd
48 1.23 mjacob #ifdef __NetBSD__
49 1.23 mjacob #include <dev/ic/isp_netbsd.h>
50 1.23 mjacob #endif
51 1.23 mjacob #ifdef __FreeBSD__
52 1.23 mjacob #include <dev/isp/isp_freebsd.h>
53 1.23 mjacob #endif
54 1.23 mjacob #ifdef __linux__
55 1.29 mjacob #include "isp_linux.h"
56 1.23 mjacob #endif
57 1.1 cgd
58 1.23 mjacob /*
59 1.23 mjacob * General defines
60 1.23 mjacob */
61 1.1 cgd
62 1.23 mjacob #define MBOX_DELAY_COUNT 1000000 / 100
63 1.1 cgd
64 1.23 mjacob /*
65 1.27 mjacob * Local static data
66 1.27 mjacob */
67 1.29 mjacob #ifdef ISP_TARGET_MODE
68 1.29 mjacob static const char tgtiqd[36] = {
69 1.29 mjacob 0x03, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00,
70 1.29 mjacob 0x51, 0x4C, 0x4F, 0x47, 0x49, 0x43, 0x20, 0x20,
71 1.29 mjacob #ifdef __NetBSD__
72 1.29 mjacob 0x4E, 0x45, 0x54, 0x42, 0x53, 0x44, 0x20, 0x20,
73 1.29 mjacob #else
74 1.29 mjacob # ifdef __FreeBSD__
75 1.29 mjacob 0x46, 0x52, 0x45, 0x45, 0x42, 0x52, 0x44, 0x20,
76 1.29 mjacob # else
77 1.29 mjacob # ifdef linux
78 1.29 mjacob 0x4C, 0x49, 0x4E, 0x55, 0x58, 0x20, 0x20, 0x20,
79 1.29 mjacob # else
80 1.29 mjacob # endif
81 1.29 mjacob # endif
82 1.29 mjacob #endif
83 1.29 mjacob 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x20, 0x20,
84 1.29 mjacob 0x20, 0x20, 0x20, 0x31
85 1.29 mjacob };
86 1.29 mjacob #endif
87 1.27 mjacob
88 1.27 mjacob
89 1.27 mjacob /*
90 1.25 mjacob * Local function prototypes.
91 1.23 mjacob */
92 1.28 mjacob static int isp_parse_async __P((struct ispsoftc *, int));
93 1.25 mjacob static int isp_handle_other_response
94 1.25 mjacob __P((struct ispsoftc *, ispstatusreq_t *, u_int8_t *));
95 1.29 mjacob #ifdef ISP_TARGET_MODE
96 1.29 mjacob static int isp_modify_lun __P((struct ispsoftc *, int, int, int));
97 1.29 mjacob static void isp_notify_ack __P((struct ispsoftc *, void *));
98 1.29 mjacob static void isp_handle_atio __P((struct ispsoftc *, void *));
99 1.29 mjacob static void isp_handle_atio2 __P((struct ispsoftc *, void *));
100 1.29 mjacob static void isp_handle_ctio __P((struct ispsoftc *, void *));
101 1.29 mjacob static void isp_handle_ctio2 __P((struct ispsoftc *, void *));
102 1.29 mjacob #endif
103 1.23 mjacob static void isp_parse_status
104 1.23 mjacob __P((struct ispsoftc *, ispstatusreq_t *, ISP_SCSI_XFER_T *));
105 1.10 mjacob static void isp_fibre_init __P((struct ispsoftc *));
106 1.10 mjacob static void isp_fw_state __P((struct ispsoftc *));
107 1.10 mjacob static void isp_dumpregs __P((struct ispsoftc *, const char *));
108 1.23 mjacob static void isp_dumpxflist __P((struct ispsoftc *));
109 1.15 mjacob static void isp_prtstst __P((ispstatusreq_t *));
110 1.28 mjacob static char *isp2100_fw_statename __P((int));
111 1.23 mjacob static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *));
112 1.1 cgd
113 1.25 mjacob static void isp_update __P((struct ispsoftc *));
114 1.25 mjacob static void isp_setdfltparm __P((struct ispsoftc *));
115 1.25 mjacob static int isp_read_nvram __P((struct ispsoftc *));
116 1.25 mjacob static void isp_rdnvram_word __P((struct ispsoftc *, int, u_int16_t *));
117 1.25 mjacob
118 1.1 cgd /*
119 1.1 cgd * Reset Hardware.
120 1.25 mjacob *
121 1.25 mjacob * Hit the chip over the head, download new f/w.
122 1.25 mjacob *
123 1.24 mjacob * Locking done elsewhere.
124 1.1 cgd */
125 1.1 cgd void
126 1.1 cgd isp_reset(isp)
127 1.1 cgd struct ispsoftc *isp;
128 1.1 cgd {
129 1.25 mjacob static char once = 1;
130 1.1 cgd mbreg_t mbs;
131 1.23 mjacob int loops, i, dodnld = 1;
132 1.10 mjacob char *revname;
133 1.1 cgd
134 1.1 cgd isp->isp_state = ISP_NILSTATE;
135 1.4 mjacob
136 1.4 mjacob /*
137 1.25 mjacob * Basic types (SCSI, FibreChannel and PCI or SBus)
138 1.25 mjacob * have been set in the MD code. We figure out more
139 1.25 mjacob * here.
140 1.4 mjacob */
141 1.23 mjacob isp->isp_dblev = DFLT_DBLEVEL;
142 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
143 1.10 mjacob revname = "2100";
144 1.10 mjacob } else {
145 1.25 mjacob sdparam *sdp = isp->isp_param;
146 1.25 mjacob
147 1.25 mjacob int rev = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
148 1.25 mjacob switch (rev) {
149 1.10 mjacob default:
150 1.25 mjacob PRINTF("%s: unknown chip rev. 0x%x- assuming a 1020\n",
151 1.25 mjacob isp->isp_name, rev);
152 1.25 mjacob /* FALLTHROUGH */
153 1.10 mjacob case 1:
154 1.25 mjacob revname = "1020";
155 1.10 mjacob isp->isp_type = ISP_HA_SCSI_1020;
156 1.25 mjacob sdp->isp_clock = 40;
157 1.22 mjacob break;
158 1.22 mjacob case 2:
159 1.25 mjacob /*
160 1.25 mjacob * Some 1020A chips are Ultra Capable, but don't
161 1.25 mjacob * run the clock rate up for that unless told to
162 1.25 mjacob * do so by the Ultra Capable bits being set.
163 1.25 mjacob */
164 1.25 mjacob revname = "1020A";
165 1.22 mjacob isp->isp_type = ISP_HA_SCSI_1020A;
166 1.25 mjacob sdp->isp_clock = 40;
167 1.10 mjacob break;
168 1.10 mjacob case 3:
169 1.25 mjacob revname = "1040";
170 1.25 mjacob isp->isp_type = ISP_HA_SCSI_1040;
171 1.25 mjacob sdp->isp_clock = 60;
172 1.25 mjacob break;
173 1.25 mjacob case 4:
174 1.10 mjacob revname = "1040A";
175 1.10 mjacob isp->isp_type = ISP_HA_SCSI_1040A;
176 1.25 mjacob sdp->isp_clock = 60;
177 1.10 mjacob break;
178 1.10 mjacob case 5:
179 1.10 mjacob revname = "1040B";
180 1.10 mjacob isp->isp_type = ISP_HA_SCSI_1040B;
181 1.25 mjacob sdp->isp_clock = 60;
182 1.10 mjacob break;
183 1.8 mjacob }
184 1.25 mjacob /*
185 1.25 mjacob * Try and figure out if we're connected to a differential bus.
186 1.25 mjacob * You have to pause the RISC processor to read SXP registers.
187 1.25 mjacob */
188 1.25 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
189 1.25 mjacob i = 100;
190 1.25 mjacob while ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
191 1.25 mjacob SYS_DELAY(20);
192 1.25 mjacob if (--i == 0) {
193 1.25 mjacob PRINTF("%s: unable to pause RISC processor\n",
194 1.25 mjacob isp->isp_name);
195 1.25 mjacob i = -1;
196 1.25 mjacob break;
197 1.25 mjacob }
198 1.25 mjacob }
199 1.25 mjacob if (i > 0) {
200 1.25 mjacob if (isp->isp_bustype != ISP_BT_SBUS) {
201 1.25 mjacob ISP_SETBITS(isp, BIU_CONF1, BIU_PCI_CONF1_SXP);
202 1.25 mjacob }
203 1.25 mjacob if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
204 1.25 mjacob IDPRINTF(2, ("%s: Differential Mode Set\n",
205 1.25 mjacob isp->isp_name));
206 1.25 mjacob sdp->isp_diffmode = 1;
207 1.25 mjacob } else {
208 1.25 mjacob sdp->isp_diffmode = 0;
209 1.25 mjacob }
210 1.25 mjacob
211 1.25 mjacob if (isp->isp_bustype != ISP_BT_SBUS) {
212 1.25 mjacob ISP_CLRBITS(isp, BIU_CONF1, BIU_PCI_CONF1_SXP);
213 1.25 mjacob }
214 1.25 mjacob
215 1.25 mjacob /*
216 1.25 mjacob * Figure out whether we're ultra capable.
217 1.25 mjacob */
218 1.25 mjacob i = ISP_READ(isp, RISC_PSR);
219 1.25 mjacob if (isp->isp_bustype != ISP_BT_SBUS) {
220 1.25 mjacob i &= RISC_PSR_PCI_ULTRA;
221 1.25 mjacob } else {
222 1.25 mjacob i &= RISC_PSR_SBUS_ULTRA;
223 1.25 mjacob }
224 1.25 mjacob if (i) {
225 1.25 mjacob IDPRINTF(2, ("%s: Ultra Mode Capable\n",
226 1.25 mjacob isp->isp_name));
227 1.25 mjacob sdp->isp_clock = 60;
228 1.25 mjacob } else {
229 1.25 mjacob sdp->isp_clock = 40;
230 1.25 mjacob }
231 1.25 mjacob /*
232 1.25 mjacob * Restart processor
233 1.25 mjacob */
234 1.25 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
235 1.25 mjacob }
236 1.25 mjacob /*
237 1.25 mjacob * Machine dependent clock (if set) overrides
238 1.25 mjacob * our generic determinations.
239 1.25 mjacob */
240 1.25 mjacob if (isp->isp_mdvec->dv_clock) {
241 1.25 mjacob if (isp->isp_mdvec->dv_clock < sdp->isp_clock) {
242 1.25 mjacob sdp->isp_clock = isp->isp_mdvec->dv_clock;
243 1.25 mjacob }
244 1.25 mjacob }
245 1.4 mjacob }
246 1.8 mjacob
247 1.1 cgd /*
248 1.10 mjacob * Do MD specific pre initialization
249 1.1 cgd */
250 1.10 mjacob ISP_RESET0(isp);
251 1.25 mjacob
252 1.25 mjacob if (once == 1) {
253 1.25 mjacob once = 0;
254 1.25 mjacob /*
255 1.25 mjacob * Get the current running firmware revision out of the
256 1.25 mjacob * chip before we hit it over the head (if this is our
257 1.25 mjacob * first time through). Note that we store this as the
258 1.25 mjacob * 'ROM' firmware revision- which it may not be. In any
259 1.25 mjacob * case, we don't really use this yet, but we may in
260 1.25 mjacob * the future.
261 1.25 mjacob */
262 1.25 mjacob mbs.param[0] = MBOX_ABOUT_FIRMWARE;
263 1.25 mjacob isp_mboxcmd(isp, &mbs);
264 1.25 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
265 1.26 mjacob IDPRINTF(3, ("%s: initial ABOUT FIRMWARE command "
266 1.26 mjacob "failed\n", isp->isp_name));
267 1.25 mjacob } else {
268 1.25 mjacob isp->isp_romfw_rev =
269 1.25 mjacob (((u_int16_t) mbs.param[1]) << 10) + mbs.param[2];
270 1.25 mjacob }
271 1.25 mjacob }
272 1.24 mjacob
273 1.1 cgd /*
274 1.10 mjacob * Hit the chip over the head with hammer,
275 1.10 mjacob * and give the ISP a chance to recover.
276 1.1 cgd */
277 1.1 cgd
278 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
279 1.10 mjacob ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
280 1.10 mjacob /*
281 1.10 mjacob * A slight delay...
282 1.10 mjacob */
283 1.23 mjacob SYS_DELAY(100);
284 1.10 mjacob
285 1.10 mjacob /*
286 1.10 mjacob * Clear data && control DMA engines.
287 1.10 mjacob */
288 1.10 mjacob ISP_WRITE(isp, CDMA_CONTROL,
289 1.1 cgd DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
290 1.10 mjacob ISP_WRITE(isp, DDMA_CONTROL,
291 1.1 cgd DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
292 1.10 mjacob } else {
293 1.10 mjacob ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
294 1.10 mjacob /*
295 1.10 mjacob * A slight delay...
296 1.10 mjacob */
297 1.23 mjacob SYS_DELAY(100);
298 1.10 mjacob ISP_WRITE(isp, CDMA2100_CONTROL,
299 1.10 mjacob DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
300 1.10 mjacob ISP_WRITE(isp, TDMA2100_CONTROL,
301 1.10 mjacob DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
302 1.10 mjacob ISP_WRITE(isp, RDMA2100_CONTROL,
303 1.10 mjacob DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
304 1.10 mjacob }
305 1.10 mjacob
306 1.1 cgd /*
307 1.1 cgd * Wait for ISP to be ready to go...
308 1.1 cgd */
309 1.1 cgd loops = MBOX_DELAY_COUNT;
310 1.10 mjacob for (;;) {
311 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
312 1.10 mjacob if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET))
313 1.10 mjacob break;
314 1.10 mjacob } else {
315 1.10 mjacob if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
316 1.10 mjacob break;
317 1.10 mjacob }
318 1.23 mjacob SYS_DELAY(100);
319 1.1 cgd if (--loops < 0) {
320 1.10 mjacob isp_dumpregs(isp, "chip reset timed out");
321 1.1 cgd return;
322 1.1 cgd }
323 1.1 cgd }
324 1.1 cgd /*
325 1.1 cgd * More initialization
326 1.1 cgd */
327 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
328 1.10 mjacob ISP_WRITE(isp, BIU_CONF1, 0);
329 1.10 mjacob } else {
330 1.10 mjacob ISP_WRITE(isp, BIU2100_CSR, 0);
331 1.25 mjacob /*
332 1.25 mjacob * All 2100's are 60Mhz with fast rams onboard.
333 1.25 mjacob */
334 1.25 mjacob ISP_WRITE(isp, RISC_MTR2100, 0x1212);
335 1.10 mjacob }
336 1.1 cgd
337 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
338 1.23 mjacob SYS_DELAY(100);
339 1.1 cgd
340 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
341 1.1 cgd ISP_SETBITS(isp, BIU_CONF1, isp->isp_mdvec->dv_conf1);
342 1.1 cgd if (isp->isp_mdvec->dv_conf1 & BIU_BURST_ENABLE) {
343 1.1 cgd ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
344 1.1 cgd ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
345 1.1 cgd }
346 1.1 cgd }
347 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
348 1.1 cgd
349 1.1 cgd /*
350 1.1 cgd * Do MD specific post initialization
351 1.1 cgd */
352 1.1 cgd ISP_RESET1(isp);
353 1.1 cgd
354 1.1 cgd /*
355 1.1 cgd * Enable interrupts
356 1.1 cgd */
357 1.10 mjacob ENABLE_INTS(isp);
358 1.1 cgd
359 1.1 cgd /*
360 1.1 cgd * Do some sanity checking.
361 1.1 cgd */
362 1.1 cgd mbs.param[0] = MBOX_NO_OP;
363 1.10 mjacob isp_mboxcmd(isp, &mbs);
364 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
365 1.10 mjacob isp_dumpregs(isp, "NOP test failed");
366 1.1 cgd return;
367 1.1 cgd }
368 1.1 cgd
369 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
370 1.10 mjacob mbs.param[0] = MBOX_MAILBOX_REG_TEST;
371 1.10 mjacob mbs.param[1] = 0xdead;
372 1.10 mjacob mbs.param[2] = 0xbeef;
373 1.10 mjacob mbs.param[3] = 0xffff;
374 1.10 mjacob mbs.param[4] = 0x1111;
375 1.10 mjacob mbs.param[5] = 0xa5a5;
376 1.10 mjacob isp_mboxcmd(isp, &mbs);
377 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
378 1.10 mjacob isp_dumpregs(isp,
379 1.10 mjacob "Mailbox Register test didn't complete");
380 1.10 mjacob return;
381 1.10 mjacob }
382 1.10 mjacob if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
383 1.10 mjacob mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
384 1.10 mjacob mbs.param[5] != 0xa5a5) {
385 1.10 mjacob isp_dumpregs(isp, "Register Test Failed");
386 1.1 cgd return;
387 1.1 cgd }
388 1.10 mjacob
389 1.1 cgd }
390 1.1 cgd
391 1.1 cgd /*
392 1.18 mjacob * Download new Firmware, unless requested not to do so.
393 1.18 mjacob * This is made slightly trickier in some cases where the
394 1.18 mjacob * firmware of the ROM revision is newer than the revision
395 1.18 mjacob * compiled into the driver. So, where we used to compare
396 1.18 mjacob * versions of our f/w and the ROM f/w, now we just see
397 1.18 mjacob * whether we have f/w at all and whether a config flag
398 1.18 mjacob * has disabled our download.
399 1.1 cgd */
400 1.23 mjacob if ((isp->isp_mdvec->dv_fwlen == 0) ||
401 1.23 mjacob (isp->isp_confopts & ISP_CFG_NORELOAD)) {
402 1.10 mjacob dodnld = 0;
403 1.10 mjacob }
404 1.10 mjacob
405 1.10 mjacob if (dodnld) {
406 1.10 mjacob for (i = 0; i < isp->isp_mdvec->dv_fwlen; i++) {
407 1.10 mjacob mbs.param[0] = MBOX_WRITE_RAM_WORD;
408 1.10 mjacob mbs.param[1] = isp->isp_mdvec->dv_codeorg + i;
409 1.10 mjacob mbs.param[2] = isp->isp_mdvec->dv_ispfw[i];
410 1.10 mjacob isp_mboxcmd(isp, &mbs);
411 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
412 1.10 mjacob isp_dumpregs(isp, "f/w download failed");
413 1.10 mjacob return;
414 1.10 mjacob }
415 1.10 mjacob }
416 1.10 mjacob
417 1.10 mjacob if (isp->isp_mdvec->dv_fwlen) {
418 1.10 mjacob /*
419 1.10 mjacob * Verify that it downloaded correctly.
420 1.10 mjacob */
421 1.10 mjacob mbs.param[0] = MBOX_VERIFY_CHECKSUM;
422 1.10 mjacob mbs.param[1] = isp->isp_mdvec->dv_codeorg;
423 1.10 mjacob isp_mboxcmd(isp, &mbs);
424 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
425 1.10 mjacob isp_dumpregs(isp, "ram checksum failure");
426 1.10 mjacob return;
427 1.10 mjacob }
428 1.10 mjacob }
429 1.10 mjacob } else {
430 1.20 mjacob IDPRINTF(3, ("%s: skipping f/w download\n", isp->isp_name));
431 1.1 cgd }
432 1.1 cgd
433 1.1 cgd /*
434 1.10 mjacob * Now start it rolling.
435 1.10 mjacob *
436 1.10 mjacob * If we didn't actually download f/w,
437 1.10 mjacob * we still need to (re)start it.
438 1.1 cgd */
439 1.1 cgd
440 1.1 cgd mbs.param[0] = MBOX_EXEC_FIRMWARE;
441 1.1 cgd mbs.param[1] = isp->isp_mdvec->dv_codeorg;
442 1.10 mjacob isp_mboxcmd(isp, &mbs);
443 1.4 mjacob
444 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
445 1.25 mjacob sdparam *sdp = isp->isp_param;
446 1.10 mjacob /*
447 1.25 mjacob * Set CLOCK RATE, but only if asked to.
448 1.10 mjacob */
449 1.25 mjacob if (sdp->isp_clock) {
450 1.10 mjacob mbs.param[0] = MBOX_SET_CLOCK_RATE;
451 1.25 mjacob mbs.param[1] = sdp->isp_clock;
452 1.10 mjacob isp_mboxcmd(isp, &mbs);
453 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
454 1.10 mjacob isp_dumpregs(isp, "failed to set CLOCKRATE");
455 1.25 mjacob /* but continue */
456 1.25 mjacob } else {
457 1.25 mjacob IDPRINTF(3, ("%s: setting input clock to %d\n",
458 1.25 mjacob isp->isp_name, sdp->isp_clock));
459 1.10 mjacob }
460 1.4 mjacob }
461 1.4 mjacob }
462 1.1 cgd mbs.param[0] = MBOX_ABOUT_FIRMWARE;
463 1.10 mjacob isp_mboxcmd(isp, &mbs);
464 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
465 1.10 mjacob isp_dumpregs(isp, "ABOUT FIRMWARE command failed");
466 1.1 cgd return;
467 1.1 cgd }
468 1.23 mjacob PRINTF("%s: Board Revision %s, %s F/W Revision %d.%d\n",
469 1.25 mjacob isp->isp_name, revname, dodnld? "loaded" : "resident",
470 1.1 cgd mbs.param[1], mbs.param[2]);
471 1.25 mjacob isp->isp_fwrev = (((u_int16_t) mbs.param[1]) << 10) + mbs.param[2];
472 1.25 mjacob if (isp->isp_romfw_rev && dodnld) {
473 1.25 mjacob PRINTF("%s: Last F/W revision was %d.%d\n", isp->isp_name,
474 1.25 mjacob isp->isp_romfw_rev >> 10, isp->isp_romfw_rev & 0x3ff);
475 1.25 mjacob }
476 1.10 mjacob isp_fw_state(isp);
477 1.1 cgd isp->isp_state = ISP_RESETSTATE;
478 1.1 cgd }
479 1.1 cgd
480 1.1 cgd /*
481 1.1 cgd * Initialize Hardware to known state
482 1.24 mjacob *
483 1.24 mjacob * Locks are held before coming here.
484 1.1 cgd */
485 1.24 mjacob
486 1.1 cgd void
487 1.1 cgd isp_init(isp)
488 1.1 cgd struct ispsoftc *isp;
489 1.1 cgd {
490 1.10 mjacob sdparam *sdp;
491 1.1 cgd mbreg_t mbs;
492 1.25 mjacob int tgt;
493 1.25 mjacob
494 1.25 mjacob /*
495 1.25 mjacob * Must do first.
496 1.25 mjacob */
497 1.25 mjacob isp_setdfltparm(isp);
498 1.25 mjacob
499 1.25 mjacob /*
500 1.25 mjacob * If we're fibre, we have a completely different
501 1.25 mjacob * initialization method.
502 1.25 mjacob */
503 1.1 cgd
504 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
505 1.10 mjacob isp_fibre_init(isp);
506 1.10 mjacob return;
507 1.1 cgd }
508 1.10 mjacob sdp = isp->isp_param;
509 1.1 cgd
510 1.10 mjacob /*
511 1.25 mjacob * Set (possibly new) Initiator ID.
512 1.10 mjacob */
513 1.25 mjacob mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
514 1.25 mjacob mbs.param[1] = sdp->isp_initiator_id;
515 1.10 mjacob isp_mboxcmd(isp, &mbs);
516 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
517 1.25 mjacob isp_dumpregs(isp, "failed to set initiator id");
518 1.1 cgd return;
519 1.1 cgd }
520 1.1 cgd
521 1.25 mjacob /*
522 1.25 mjacob * Set Retry Delay and Count
523 1.25 mjacob */
524 1.1 cgd mbs.param[0] = MBOX_SET_RETRY_COUNT;
525 1.10 mjacob mbs.param[1] = sdp->isp_retry_count;
526 1.10 mjacob mbs.param[2] = sdp->isp_retry_delay;
527 1.10 mjacob isp_mboxcmd(isp, &mbs);
528 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
529 1.10 mjacob isp_dumpregs(isp, "failed to set retry count and delay");
530 1.1 cgd return;
531 1.1 cgd }
532 1.1 cgd
533 1.25 mjacob /*
534 1.25 mjacob * Set ASYNC DATA SETUP time. This is very important.
535 1.25 mjacob */
536 1.1 cgd mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
537 1.10 mjacob mbs.param[1] = sdp->isp_async_data_setup;
538 1.10 mjacob isp_mboxcmd(isp, &mbs);
539 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
540 1.10 mjacob isp_dumpregs(isp, "failed to set async data setup time");
541 1.1 cgd return;
542 1.1 cgd }
543 1.1 cgd
544 1.25 mjacob /*
545 1.25 mjacob * Set ACTIVE Negation State.
546 1.25 mjacob */
547 1.1 cgd mbs.param[0] = MBOX_SET_ACTIVE_NEG_STATE;
548 1.25 mjacob mbs.param[1] =
549 1.25 mjacob (sdp->isp_req_ack_active_neg << 4) |
550 1.25 mjacob (sdp->isp_data_line_active_neg << 5);
551 1.10 mjacob isp_mboxcmd(isp, &mbs);
552 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
553 1.10 mjacob isp_dumpregs(isp, "failed to set active neg state");
554 1.1 cgd return;
555 1.1 cgd }
556 1.1 cgd
557 1.25 mjacob /*
558 1.25 mjacob * Set the Tag Aging limit
559 1.25 mjacob */
560 1.25 mjacob
561 1.1 cgd mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
562 1.10 mjacob mbs.param[1] = sdp->isp_tag_aging;
563 1.10 mjacob isp_mboxcmd(isp, &mbs);
564 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
565 1.10 mjacob isp_dumpregs(isp, "failed to set tag age limit");
566 1.1 cgd return;
567 1.1 cgd }
568 1.1 cgd
569 1.25 mjacob /*
570 1.25 mjacob * Set selection timeout.
571 1.25 mjacob */
572 1.25 mjacob
573 1.1 cgd mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
574 1.10 mjacob mbs.param[1] = sdp->isp_selection_timeout;
575 1.10 mjacob isp_mboxcmd(isp, &mbs);
576 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
577 1.10 mjacob isp_dumpregs(isp, "failed to set selection timeout");
578 1.1 cgd return;
579 1.1 cgd }
580 1.1 cgd
581 1.25 mjacob /*
582 1.25 mjacob * Set per-target parameters to a safe minimum.
583 1.25 mjacob */
584 1.25 mjacob
585 1.25 mjacob for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
586 1.25 mjacob int maxlun, lun;
587 1.10 mjacob
588 1.25 mjacob if (sdp->isp_devparam[tgt].dev_enable == 0)
589 1.1 cgd continue;
590 1.1 cgd
591 1.25 mjacob mbs.param[0] = MBOX_SET_TARGET_PARAMS;
592 1.25 mjacob mbs.param[1] = tgt << 8;
593 1.25 mjacob mbs.param[2] = DPARM_SAFE_DFLT;
594 1.25 mjacob mbs.param[3] = 0;
595 1.20 mjacob /*
596 1.25 mjacob * It is not quite clear when this changed over so that
597 1.25 mjacob * we could force narrow and async, so assume >= 7.55.
598 1.25 mjacob *
599 1.25 mjacob * Otherwise, a SCSI bus reset issued below will force
600 1.25 mjacob * the back to the narrow, async state (but see note
601 1.25 mjacob * below also). Technically we should also do without
602 1.25 mjacob * Parity.
603 1.20 mjacob */
604 1.25 mjacob if (isp->isp_fwrev >= ISP_FW_REV(7, 55)) {
605 1.25 mjacob mbs.param[2] |= DPARM_NARROW | DPARM_ASYNC;
606 1.20 mjacob }
607 1.25 mjacob sdp->isp_devparam[tgt].cur_dflags = mbs.param[2] >> 8;
608 1.10 mjacob
609 1.25 mjacob IDPRINTF(3, ("\n%s: tgt %d cflags %x offset %x period %x\n",
610 1.25 mjacob isp->isp_name, tgt, mbs.param[2], mbs.param[3] >> 8,
611 1.25 mjacob mbs.param[3] & 0xff));
612 1.10 mjacob isp_mboxcmd(isp, &mbs);
613 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
614 1.25 mjacob
615 1.25 mjacob PRINTF("%s: failed to set parameters for tgt %d\n",
616 1.25 mjacob isp->isp_name, tgt);
617 1.25 mjacob
618 1.23 mjacob PRINTF("%s: flags %x offset %x period %x\n",
619 1.25 mjacob isp->isp_name, sdp->isp_devparam[tgt].dev_flags,
620 1.25 mjacob sdp->isp_devparam[tgt].sync_offset,
621 1.25 mjacob sdp->isp_devparam[tgt].sync_period);
622 1.25 mjacob
623 1.10 mjacob mbs.param[0] = MBOX_SET_TARGET_PARAMS;
624 1.25 mjacob mbs.param[1] = tgt << 8;
625 1.25 mjacob mbs.param[2] = DPARM_SAFE_DFLT;
626 1.25 mjacob mbs.param[3] = 0;
627 1.10 mjacob isp_mboxcmd(isp, &mbs);
628 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
629 1.25 mjacob PRINTF("%s: failed even to set defaults for "
630 1.25 mjacob "target %d\n", isp->isp_name, tgt);
631 1.25 mjacob continue;
632 1.10 mjacob }
633 1.1 cgd }
634 1.25 mjacob
635 1.25 mjacob maxlun = (isp->isp_fwrev >= ISP_FW_REV(7, 55))? 32 : 8;
636 1.25 mjacob for (lun = 0; lun < maxlun; lun++) {
637 1.1 cgd mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
638 1.25 mjacob mbs.param[1] = (tgt << 8) | lun;
639 1.10 mjacob mbs.param[2] = sdp->isp_max_queue_depth;
640 1.25 mjacob mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
641 1.10 mjacob isp_mboxcmd(isp, &mbs);
642 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
643 1.25 mjacob PRINTF("%s: failed to set device queue "
644 1.25 mjacob "parameters for target %d, lun %d\n",
645 1.25 mjacob isp->isp_name, tgt, lun);
646 1.25 mjacob break;
647 1.1 cgd }
648 1.1 cgd }
649 1.1 cgd }
650 1.1 cgd
651 1.7 thorpej /*
652 1.7 thorpej * Set up DMA for the request and result mailboxes.
653 1.7 thorpej */
654 1.27 mjacob if (ISP_MBOXDMASETUP(isp) != 0) {
655 1.23 mjacob PRINTF("%s: can't setup dma mailboxes\n", isp->isp_name);
656 1.1 cgd return;
657 1.1 cgd }
658 1.10 mjacob
659 1.1 cgd mbs.param[0] = MBOX_INIT_RES_QUEUE;
660 1.23 mjacob mbs.param[1] = RESULT_QUEUE_LEN;
661 1.7 thorpej mbs.param[2] = (u_int16_t) (isp->isp_result_dma >> 16);
662 1.7 thorpej mbs.param[3] = (u_int16_t) (isp->isp_result_dma & 0xffff);
663 1.1 cgd mbs.param[4] = 0;
664 1.6 mjacob mbs.param[5] = 0;
665 1.10 mjacob isp_mboxcmd(isp, &mbs);
666 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
667 1.10 mjacob isp_dumpregs(isp, "set of response queue failed");
668 1.1 cgd return;
669 1.1 cgd }
670 1.1 cgd isp->isp_residx = 0;
671 1.1 cgd
672 1.1 cgd mbs.param[0] = MBOX_INIT_REQ_QUEUE;
673 1.23 mjacob mbs.param[1] = RQUEST_QUEUE_LEN;
674 1.7 thorpej mbs.param[2] = (u_int16_t) (isp->isp_rquest_dma >> 16);
675 1.7 thorpej mbs.param[3] = (u_int16_t) (isp->isp_rquest_dma & 0xffff);
676 1.1 cgd mbs.param[4] = 0;
677 1.10 mjacob mbs.param[5] = 0;
678 1.10 mjacob isp_mboxcmd(isp, &mbs);
679 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
680 1.10 mjacob isp_dumpregs(isp, "set of request queue failed");
681 1.1 cgd return;
682 1.1 cgd }
683 1.25 mjacob isp->isp_reqidx = isp->isp_reqodx = 0;
684 1.1 cgd
685 1.1 cgd /*
686 1.25 mjacob * XXX: See whether or not for 7.55 F/W or later we
687 1.25 mjacob * XXX: can do without this, and see whether we should
688 1.25 mjacob * XXX: honor the NVRAM SCSI_RESET_DISABLE token.
689 1.1 cgd */
690 1.1 cgd mbs.param[0] = MBOX_BUS_RESET;
691 1.25 mjacob mbs.param[1] = 3;
692 1.10 mjacob isp_mboxcmd(isp, &mbs);
693 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
694 1.10 mjacob isp_dumpregs(isp, "SCSI bus reset failed");
695 1.1 cgd }
696 1.10 mjacob /*
697 1.10 mjacob * This is really important to have set after a bus reset.
698 1.10 mjacob */
699 1.1 cgd isp->isp_sendmarker = 1;
700 1.1 cgd isp->isp_state = ISP_INITSTATE;
701 1.1 cgd }
702 1.1 cgd
703 1.24 mjacob /*
704 1.24 mjacob * Fibre Channel specific initialization.
705 1.24 mjacob *
706 1.24 mjacob * Locks are held before coming here.
707 1.24 mjacob */
708 1.10 mjacob static void
709 1.10 mjacob isp_fibre_init(isp)
710 1.10 mjacob struct ispsoftc *isp;
711 1.10 mjacob {
712 1.10 mjacob fcparam *fcp;
713 1.10 mjacob isp_icb_t *icbp;
714 1.10 mjacob mbreg_t mbs;
715 1.28 mjacob int count, loopid;
716 1.23 mjacob u_int8_t lwfs;
717 1.10 mjacob
718 1.10 mjacob fcp = isp->isp_param;
719 1.10 mjacob
720 1.27 mjacob if (ISP_MBOXDMASETUP(isp) != 0) {
721 1.23 mjacob PRINTF("%s: can't setup DMA for mailboxes\n", isp->isp_name);
722 1.10 mjacob return;
723 1.10 mjacob }
724 1.28 mjacob /*
725 1.28 mjacob * For systems that don't have BIOS methods for which
726 1.28 mjacob * we can easily change the NVRAM based loopid, we'll
727 1.28 mjacob * override that here. Note that when we initialize
728 1.28 mjacob * the firmware we may get back a different loopid than
729 1.28 mjacob * we asked for anyway. XXX This is probably not the
730 1.28 mjacob * best way to figure this out XXX
731 1.28 mjacob */
732 1.28 mjacob #ifndef __i386__
733 1.28 mjacob loopid = DEFAULT_LOOPID;
734 1.28 mjacob #else
735 1.28 mjacob loopid = fcp->isp_loopid;
736 1.28 mjacob #endif
737 1.28 mjacob
738 1.10 mjacob
739 1.10 mjacob icbp = (isp_icb_t *) fcp->isp_scratch;
740 1.10 mjacob bzero(icbp, sizeof (*icbp));
741 1.25 mjacob
742 1.25 mjacob icbp->icb_version = ICB_VERSION1;
743 1.29 mjacob #ifdef ISP_TARGET_MODE
744 1.29 mjacob fcp->isp_fwoptions = ICBOPT_TGT_ENABLE|ICBOPT_INI_TGTTYPE;
745 1.29 mjacob #else
746 1.27 mjacob fcp->isp_fwoptions = 0;
747 1.29 mjacob #endif
748 1.28 mjacob fcp->isp_fwoptions |= ICBOPT_INI_ADISC|ICBOPT_FAIRNESS;
749 1.28 mjacob fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
750 1.28 mjacob fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
751 1.28 mjacob #ifdef CHECKME
752 1.28 mjacob fcp->isp_fwoptions |= ICBOPT_USE_PORTNAME;
753 1.28 mjacob #endif
754 1.28 mjacob #ifdef THIS_WORKED
755 1.28 mjacob /*
756 1.28 mjacob * This has unhappiness in target mode
757 1.28 mjacob */
758 1.28 mjacob fcp->isp_fwoptions |= ICBOPT_FULL_LOGIN;
759 1.27 mjacob #endif
760 1.27 mjacob icbp->icb_fwoptions = fcp->isp_fwoptions;
761 1.25 mjacob icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
762 1.25 mjacob if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
763 1.25 mjacob icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
764 1.25 mjacob PRINTF("%s: bad frame length (%d) from NVRAM- using %d\n",
765 1.25 mjacob isp->isp_name, fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
766 1.25 mjacob }
767 1.25 mjacob icbp->icb_maxalloc = fcp->isp_maxalloc;
768 1.25 mjacob icbp->icb_execthrottle = fcp->isp_execthrottle;
769 1.25 mjacob icbp->icb_retry_delay = fcp->isp_retry_delay;
770 1.25 mjacob icbp->icb_retry_count = fcp->isp_retry_count;
771 1.28 mjacob icbp->icb_hardaddr = loopid;
772 1.25 mjacob
773 1.25 mjacob MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwn);
774 1.28 mjacob if (icbp->icb_fwoptions & ICBOPT_USE_PORTNAME) {
775 1.28 mjacob u_int64_t portname = fcp->isp_wwn | (2LL << 56);
776 1.28 mjacob MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, portname);
777 1.28 mjacob }
778 1.23 mjacob icbp->icb_rqstqlen = RQUEST_QUEUE_LEN;
779 1.23 mjacob icbp->icb_rsltqlen = RESULT_QUEUE_LEN;
780 1.25 mjacob icbp->icb_rqstaddr[RQRSP_ADDR0015] =
781 1.25 mjacob (u_int16_t) (isp->isp_rquest_dma & 0xffff);
782 1.25 mjacob icbp->icb_rqstaddr[RQRSP_ADDR1631] =
783 1.25 mjacob (u_int16_t) (isp->isp_rquest_dma >> 16);
784 1.25 mjacob icbp->icb_respaddr[RQRSP_ADDR0015] =
785 1.25 mjacob (u_int16_t) (isp->isp_result_dma & 0xffff);
786 1.25 mjacob icbp->icb_respaddr[RQRSP_ADDR1631] =
787 1.25 mjacob (u_int16_t) (isp->isp_result_dma >> 16);
788 1.10 mjacob
789 1.27 mjacob for (count = 0; count < 10; count++) {
790 1.27 mjacob mbs.param[0] = MBOX_INIT_FIRMWARE;
791 1.27 mjacob mbs.param[1] = 0;
792 1.27 mjacob mbs.param[2] = (u_int16_t) (fcp->isp_scdma >> 16);
793 1.27 mjacob mbs.param[3] = (u_int16_t) (fcp->isp_scdma & 0xffff);
794 1.27 mjacob mbs.param[4] = 0;
795 1.27 mjacob mbs.param[5] = 0;
796 1.27 mjacob mbs.param[6] = 0;
797 1.27 mjacob mbs.param[7] = 0;
798 1.27 mjacob
799 1.27 mjacob isp_mboxcmd(isp, &mbs);
800 1.27 mjacob
801 1.27 mjacob switch (mbs.param[0]) {
802 1.27 mjacob case MBOX_COMMAND_COMPLETE:
803 1.27 mjacob count = 10;
804 1.27 mjacob break;
805 1.27 mjacob case ASYNC_LIP_OCCURRED:
806 1.27 mjacob case ASYNC_LOOP_UP:
807 1.27 mjacob case ASYNC_LOOP_DOWN:
808 1.27 mjacob case ASYNC_LOOP_RESET:
809 1.27 mjacob case ASYNC_PDB_CHANGED:
810 1.27 mjacob case ASYNC_CHANGE_NOTIFY:
811 1.27 mjacob if (count > 9) {
812 1.27 mjacob PRINTF("%s: too many retries to get going- "
813 1.27 mjacob "giving up\n", isp->isp_name);
814 1.27 mjacob return;
815 1.27 mjacob }
816 1.27 mjacob break;
817 1.27 mjacob default:
818 1.27 mjacob isp_dumpregs(isp, "INIT FIRMWARE failed");
819 1.27 mjacob return;
820 1.27 mjacob }
821 1.10 mjacob }
822 1.25 mjacob isp->isp_reqidx = isp->isp_reqodx = 0;
823 1.10 mjacob isp->isp_residx = 0;
824 1.10 mjacob
825 1.10 mjacob /*
826 1.28 mjacob * Wait up to 5 seconds for FW to go to READY state.
827 1.10 mjacob */
828 1.23 mjacob lwfs = FW_CONFIG_WAIT;
829 1.23 mjacob for (count = 0; count < 12000; count++) {
830 1.10 mjacob isp_fw_state(isp);
831 1.23 mjacob if (lwfs != fcp->isp_fwstate) {
832 1.28 mjacob PRINTF("%s: Firmware State %s -> %s\n",
833 1.28 mjacob isp->isp_name, isp2100_fw_statename((int)lwfs),
834 1.28 mjacob isp2100_fw_statename((int)fcp->isp_fwstate));
835 1.23 mjacob lwfs = fcp->isp_fwstate;
836 1.23 mjacob }
837 1.23 mjacob if (fcp->isp_fwstate == FW_READY) {
838 1.10 mjacob break;
839 1.23 mjacob }
840 1.23 mjacob SYS_DELAY(1000); /* wait one millisecond */
841 1.10 mjacob }
842 1.13 mjacob isp->isp_sendmarker = 1;
843 1.10 mjacob
844 1.10 mjacob /*
845 1.23 mjacob * Get our Loop ID
846 1.23 mjacob * (if possible)
847 1.10 mjacob */
848 1.23 mjacob if (fcp->isp_fwstate == FW_READY) {
849 1.10 mjacob mbs.param[0] = MBOX_GET_LOOP_ID;
850 1.10 mjacob isp_mboxcmd(isp, &mbs);
851 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
852 1.10 mjacob isp_dumpregs(isp, "GET LOOP ID failed");
853 1.10 mjacob return;
854 1.10 mjacob }
855 1.10 mjacob fcp->isp_loopid = mbs.param[1];
856 1.25 mjacob fcp->isp_alpa = mbs.param[2];
857 1.28 mjacob PRINTF("%s: Loop ID %d, ALPA 0x%x\n", isp->isp_name,
858 1.27 mjacob fcp->isp_loopid, fcp->isp_alpa);
859 1.27 mjacob isp->isp_state = ISP_INITSTATE;
860 1.29 mjacob #ifdef ISP_TARGET_MODE
861 1.29 mjacob DISABLE_INTS(isp);
862 1.29 mjacob if (isp_modify_lun(isp, 0, 1, 1)) {
863 1.29 mjacob PRINTF("%s: failed to enable target mode\n",
864 1.29 mjacob isp->isp_name);
865 1.29 mjacob }
866 1.29 mjacob ENABLE_INTS(isp);
867 1.29 mjacob #endif
868 1.10 mjacob } else {
869 1.23 mjacob PRINTF("%s: failed to go to FW READY state- will not attach\n",
870 1.23 mjacob isp->isp_name);
871 1.23 mjacob }
872 1.1 cgd }
873 1.1 cgd
874 1.1 cgd /*
875 1.23 mjacob * Start a command. Locking is assumed done in the caller.
876 1.1 cgd */
877 1.23 mjacob
878 1.23 mjacob int32_t
879 1.1 cgd ispscsicmd(xs)
880 1.23 mjacob ISP_SCSI_XFER_T *xs;
881 1.1 cgd {
882 1.1 cgd struct ispsoftc *isp;
883 1.1 cgd u_int8_t iptr, optr;
884 1.10 mjacob union {
885 1.10 mjacob ispreq_t *_reqp;
886 1.10 mjacob ispreqt2_t *_t2reqp;
887 1.10 mjacob } _u;
888 1.10 mjacob #define reqp _u._reqp
889 1.10 mjacob #define t2reqp _u._t2reqp
890 1.16 mjacob #define UZSIZE max(sizeof (ispreq_t), sizeof (ispreqt2_t))
891 1.23 mjacob int i;
892 1.1 cgd
893 1.23 mjacob XS_INITERR(xs);
894 1.23 mjacob isp = XS_ISP(xs);
895 1.1 cgd
896 1.24 mjacob if (isp->isp_state != ISP_RUNSTATE) {
897 1.24 mjacob PRINTF("%s: adapter not ready\n", isp->isp_name);
898 1.24 mjacob XS_SETERR(xs, HBA_BOTCH);
899 1.24 mjacob return (CMD_COMPLETE);
900 1.24 mjacob }
901 1.24 mjacob
902 1.25 mjacob /*
903 1.25 mjacob * We *could* do the different sequence type that has clos
904 1.25 mjacob * to the whole Queue Entry for the command,.
905 1.25 mjacob */
906 1.25 mjacob if (XS_CDBLEN(xs) > ((isp->isp_type & ISP_HA_FC)? 16 : 12)) {
907 1.25 mjacob PRINTF("%s: unsupported cdb length (%d)\n",
908 1.25 mjacob isp->isp_name, XS_CDBLEN(xs));
909 1.25 mjacob XS_SETERR(xs, HBA_BOTCH);
910 1.25 mjacob return (CMD_COMPLETE);
911 1.25 mjacob }
912 1.25 mjacob
913 1.25 mjacob /*
914 1.25 mjacob * First check to see if any HBA or Device
915 1.25 mjacob * parameters need to be updated.
916 1.25 mjacob */
917 1.25 mjacob if (isp->isp_update) {
918 1.25 mjacob isp_update(isp);
919 1.10 mjacob }
920 1.25 mjacob
921 1.25 mjacob optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4);
922 1.1 cgd iptr = isp->isp_reqidx;
923 1.1 cgd
924 1.10 mjacob reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
925 1.25 mjacob iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN);
926 1.1 cgd if (iptr == optr) {
927 1.27 mjacob IDPRINTF(2, ("%s: Request Queue Overflow\n", isp->isp_name));
928 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
929 1.23 mjacob return (CMD_EAGAIN);
930 1.1 cgd }
931 1.23 mjacob if (isp->isp_type & ISP_HA_FC) {
932 1.13 mjacob DISABLE_INTS(isp);
933 1.23 mjacob }
934 1.13 mjacob
935 1.1 cgd if (isp->isp_sendmarker) {
936 1.25 mjacob u_int8_t niptr;
937 1.10 mjacob ispmarkreq_t *marker = (ispmarkreq_t *) reqp;
938 1.1 cgd
939 1.1 cgd bzero((void *) marker, sizeof (*marker));
940 1.1 cgd marker->req_header.rqs_entry_count = 1;
941 1.1 cgd marker->req_header.rqs_entry_type = RQSTYPE_MARKER;
942 1.1 cgd marker->req_modifier = SYNC_ALL;
943 1.1 cgd
944 1.1 cgd isp->isp_sendmarker = 0;
945 1.1 cgd
946 1.27 mjacob /*
947 1.27 mjacob * Unconditionally update the input pointer anyway.
948 1.27 mjacob */
949 1.27 mjacob ISP_WRITE(isp, INMAILBOX4, iptr);
950 1.27 mjacob isp->isp_reqidx = iptr;
951 1.27 mjacob
952 1.25 mjacob niptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN);
953 1.25 mjacob if (niptr == optr) {
954 1.23 mjacob if (isp->isp_type & ISP_HA_FC) {
955 1.13 mjacob ENABLE_INTS(isp);
956 1.23 mjacob }
957 1.27 mjacob IDPRINTF(2, ("%s: Request Queue Overflow+\n",
958 1.27 mjacob isp->isp_name));
959 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
960 1.23 mjacob return (CMD_EAGAIN);
961 1.1 cgd }
962 1.10 mjacob reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
963 1.25 mjacob iptr = niptr;
964 1.1 cgd }
965 1.1 cgd
966 1.16 mjacob bzero((void *) reqp, UZSIZE);
967 1.10 mjacob reqp->req_header.rqs_entry_count = 1;
968 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
969 1.10 mjacob reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
970 1.10 mjacob } else {
971 1.10 mjacob reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
972 1.10 mjacob }
973 1.10 mjacob reqp->req_header.rqs_flags = 0;
974 1.10 mjacob reqp->req_header.rqs_seqno = isp->isp_seqno++;
975 1.1 cgd
976 1.23 mjacob for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
977 1.1 cgd if (isp->isp_xflist[i] == NULL)
978 1.1 cgd break;
979 1.1 cgd }
980 1.23 mjacob if (i == RQUEST_QUEUE_LEN) {
981 1.23 mjacob if (isp->isp_type & ISP_HA_FC)
982 1.23 mjacob ENABLE_INTS(isp);
983 1.27 mjacob IDPRINTF(2, ("%s: out of xflist pointers\n", isp->isp_name));
984 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
985 1.23 mjacob return (CMD_EAGAIN);
986 1.1 cgd } else {
987 1.10 mjacob /*
988 1.10 mjacob * Never have a handle that is zero, so
989 1.10 mjacob * set req_handle off by one.
990 1.10 mjacob */
991 1.1 cgd isp->isp_xflist[i] = xs;
992 1.10 mjacob reqp->req_handle = i+1;
993 1.1 cgd }
994 1.1 cgd
995 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
996 1.10 mjacob /*
997 1.10 mjacob * See comment in isp_intr
998 1.10 mjacob */
999 1.23 mjacob XS_RESID(xs) = 0;
1000 1.10 mjacob /*
1001 1.16 mjacob * Fibre Channel always requires some kind of tag.
1002 1.23 mjacob * If we're marked as "Can't Tag", just do simple
1003 1.23 mjacob * instead of ordered tags. It's pretty clear to me
1004 1.23 mjacob * that we shouldn't do head of queue tagging in
1005 1.23 mjacob * this case.
1006 1.10 mjacob */
1007 1.23 mjacob if (XS_CANTAG(xs)) {
1008 1.23 mjacob t2reqp->req_flags = XS_KINDOF_TAG(xs);
1009 1.10 mjacob } else {
1010 1.23 mjacob t2reqp->req_flags = REQFLAG_STAG;
1011 1.10 mjacob }
1012 1.10 mjacob } else {
1013 1.23 mjacob sdparam *sdp = (sdparam *)isp->isp_param;
1014 1.25 mjacob if ((sdp->isp_devparam[XS_TGT(xs)].cur_dflags & DPARM_TQING) &&
1015 1.23 mjacob XS_CANTAG(xs)) {
1016 1.23 mjacob reqp->req_flags = XS_KINDOF_TAG(xs);
1017 1.23 mjacob } else {
1018 1.10 mjacob reqp->req_flags = 0;
1019 1.10 mjacob }
1020 1.10 mjacob }
1021 1.23 mjacob reqp->req_target = XS_TGT(xs);
1022 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
1023 1.28 mjacob reqp->req_lun_trn = XS_LUN(xs);
1024 1.23 mjacob reqp->req_cdblen = XS_CDBLEN(xs);
1025 1.28 mjacob } else {
1026 1.28 mjacob #ifdef SCCLUN
1027 1.28 mjacob reqp->req_scclun = XS_LUN(xs);
1028 1.28 mjacob #else
1029 1.28 mjacob reqp->req_lun_trn = XS_LUN(xs);
1030 1.28 mjacob #endif
1031 1.28 mjacob
1032 1.10 mjacob }
1033 1.23 mjacob bcopy((void *)XS_CDBP(xs), reqp->req_cdb, XS_CDBLEN(xs));
1034 1.1 cgd
1035 1.23 mjacob IDPRINTF(5, ("%s(%d.%d): START%d cmd 0x%x datalen %d\n", isp->isp_name,
1036 1.23 mjacob XS_TGT(xs), XS_LUN(xs), reqp->req_header.rqs_seqno,
1037 1.23 mjacob reqp->req_cdb[0], XS_XFRLEN(xs)));
1038 1.1 cgd
1039 1.23 mjacob reqp->req_time = XS_TIME(xs) / 1000;
1040 1.23 mjacob if (reqp->req_time == 0 && XS_TIME(xs))
1041 1.10 mjacob reqp->req_time = 1;
1042 1.27 mjacob i = ISP_DMASETUP(isp, xs, reqp, &iptr, optr);
1043 1.27 mjacob if (i != CMD_QUEUED) {
1044 1.13 mjacob if (isp->isp_type & ISP_HA_FC)
1045 1.13 mjacob ENABLE_INTS(isp);
1046 1.27 mjacob /*
1047 1.27 mjacob * dmasetup sets actual error in packet, and
1048 1.27 mjacob * return what we were given to return.
1049 1.27 mjacob */
1050 1.27 mjacob return (i);
1051 1.1 cgd }
1052 1.23 mjacob XS_SETERR(xs, HBA_NOERROR);
1053 1.1 cgd ISP_WRITE(isp, INMAILBOX4, iptr);
1054 1.1 cgd isp->isp_reqidx = iptr;
1055 1.23 mjacob if (isp->isp_type & ISP_HA_FC) {
1056 1.13 mjacob ENABLE_INTS(isp);
1057 1.3 cgd }
1058 1.23 mjacob isp->isp_nactive++;
1059 1.23 mjacob return (CMD_QUEUED);
1060 1.10 mjacob #undef reqp
1061 1.10 mjacob #undef t2reqp
1062 1.1 cgd }
1063 1.1 cgd
1064 1.1 cgd /*
1065 1.23 mjacob * isp control
1066 1.23 mjacob * Locks (ints blocked) assumed held.
1067 1.1 cgd */
1068 1.1 cgd
1069 1.1 cgd int
1070 1.23 mjacob isp_control(isp, ctl, arg)
1071 1.1 cgd struct ispsoftc *isp;
1072 1.23 mjacob ispctl_t ctl;
1073 1.23 mjacob void *arg;
1074 1.1 cgd {
1075 1.23 mjacob ISP_SCSI_XFER_T *xs;
1076 1.23 mjacob mbreg_t mbs;
1077 1.23 mjacob int i;
1078 1.3 cgd
1079 1.23 mjacob switch (ctl) {
1080 1.23 mjacob default:
1081 1.23 mjacob PRINTF("%s: isp_control unknown control op %x\n",
1082 1.23 mjacob isp->isp_name, ctl);
1083 1.23 mjacob break;
1084 1.3 cgd
1085 1.23 mjacob case ISPCTL_RESET_BUS:
1086 1.23 mjacob mbs.param[0] = MBOX_BUS_RESET;
1087 1.27 mjacob mbs.param[1] = (isp->isp_type & ISP_HA_FC)? 5: 2;
1088 1.23 mjacob isp_mboxcmd(isp, &mbs);
1089 1.23 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1090 1.23 mjacob isp_dumpregs(isp, "isp_control SCSI bus reset failed");
1091 1.23 mjacob break;
1092 1.23 mjacob }
1093 1.23 mjacob /*
1094 1.23 mjacob * This is really important to have set after a bus reset.
1095 1.23 mjacob */
1096 1.23 mjacob isp->isp_sendmarker = 1;
1097 1.25 mjacob PRINTF("%s: driver initiated bus reset\n", isp->isp_name);
1098 1.23 mjacob return (0);
1099 1.23 mjacob
1100 1.23 mjacob case ISPCTL_RESET_DEV:
1101 1.23 mjacob /*
1102 1.23 mjacob * Note that under parallel SCSI, this issues a BDR message.
1103 1.23 mjacob * Under FC, we could probably be using ABORT TASK SET
1104 1.23 mjacob * command.
1105 1.23 mjacob */
1106 1.23 mjacob
1107 1.23 mjacob mbs.param[0] = MBOX_ABORT_TARGET;
1108 1.23 mjacob mbs.param[1] = ((long)arg) << 8;
1109 1.23 mjacob mbs.param[2] = 2; /* 'delay', in seconds */
1110 1.23 mjacob isp_mboxcmd(isp, &mbs);
1111 1.23 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1112 1.23 mjacob isp_dumpregs(isp, "SCSI Target reset failed");
1113 1.23 mjacob break;
1114 1.23 mjacob }
1115 1.23 mjacob PRINTF("%s: Target %d Reset Succeeded\n", isp->isp_name,
1116 1.23 mjacob (int) ((long) arg));
1117 1.23 mjacob isp->isp_sendmarker = 1;
1118 1.23 mjacob return (0);
1119 1.23 mjacob
1120 1.23 mjacob case ISPCTL_ABORT_CMD:
1121 1.23 mjacob xs = (ISP_SCSI_XFER_T *) arg;
1122 1.23 mjacob for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
1123 1.23 mjacob if (xs == isp->isp_xflist[i]) {
1124 1.23 mjacob break;
1125 1.23 mjacob }
1126 1.23 mjacob }
1127 1.23 mjacob if (i == RQUEST_QUEUE_LEN) {
1128 1.23 mjacob PRINTF("%s: isp_control- cannot find command to abort "
1129 1.23 mjacob "in active list\n", isp->isp_name);
1130 1.23 mjacob break;
1131 1.23 mjacob }
1132 1.23 mjacob mbs.param[0] = MBOX_ABORT;
1133 1.28 mjacob #ifdef SCCLUN
1134 1.28 mjacob if (isp->isp_type & ISP_HA_FC) {
1135 1.28 mjacob mbs.param[1] = XS_TGT(xs) << 8;
1136 1.28 mjacob mbs.param[4] = 0;
1137 1.28 mjacob mbs.param[5] = 0;
1138 1.28 mjacob mbs.param[6] = XS_LUN(xs);
1139 1.28 mjacob } else {
1140 1.28 mjacob mbs.param[1] = XS_TGT(xs) << 8 | XS_LUN(xs);
1141 1.28 mjacob }
1142 1.28 mjacob #else
1143 1.28 mjacob mbs.param[1] = XS_TGT(xs) << 8 | XS_LUN(xs);
1144 1.28 mjacob #endif
1145 1.23 mjacob mbs.param[2] = (i+1) >> 16;
1146 1.23 mjacob mbs.param[3] = (i+1) & 0xffff;
1147 1.23 mjacob isp_mboxcmd(isp, &mbs);
1148 1.23 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1149 1.23 mjacob PRINTF("%s: isp_control MBOX_ABORT failure (code %x)\n",
1150 1.23 mjacob isp->isp_name, mbs.param[0]);
1151 1.23 mjacob break;
1152 1.23 mjacob }
1153 1.23 mjacob PRINTF("%s: command for target %d lun %d was aborted\n",
1154 1.23 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
1155 1.23 mjacob return (0);
1156 1.26 mjacob
1157 1.26 mjacob case ISPCTL_UPDATE_PARAMS:
1158 1.26 mjacob isp_update(isp);
1159 1.26 mjacob return(0);
1160 1.1 cgd }
1161 1.23 mjacob return (-1);
1162 1.1 cgd }
1163 1.1 cgd
1164 1.23 mjacob /*
1165 1.23 mjacob * Interrupt Service Routine(s).
1166 1.23 mjacob *
1167 1.23 mjacob * External (OS) framework has done the appropriate locking,
1168 1.23 mjacob * and the locking will be held throughout this function.
1169 1.23 mjacob */
1170 1.23 mjacob
1171 1.1 cgd int
1172 1.1 cgd isp_intr(arg)
1173 1.1 cgd void *arg;
1174 1.1 cgd {
1175 1.25 mjacob ISP_SCSI_XFER_T *complist[RESULT_QUEUE_LEN], *xs;
1176 1.1 cgd struct ispsoftc *isp = arg;
1177 1.25 mjacob u_int8_t iptr, optr;
1178 1.25 mjacob u_int16_t isr;
1179 1.23 mjacob int i, ndone = 0;
1180 1.1 cgd
1181 1.1 cgd isr = ISP_READ(isp, BIU_ISR);
1182 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
1183 1.10 mjacob if (isr == 0 || (isr & BIU2100_ISR_RISC_INT) == 0) {
1184 1.10 mjacob if (isr) {
1185 1.20 mjacob IDPRINTF(4, ("%s: isp_intr isr=%x\n",
1186 1.10 mjacob isp->isp_name, isr));
1187 1.10 mjacob }
1188 1.10 mjacob return (0);
1189 1.10 mjacob }
1190 1.10 mjacob } else {
1191 1.10 mjacob if (isr == 0 || (isr & BIU_ISR_RISC_INT) == 0) {
1192 1.10 mjacob if (isr) {
1193 1.20 mjacob IDPRINTF(4, ("%s: isp_intr isr=%x\n",
1194 1.10 mjacob isp->isp_name, isr));
1195 1.10 mjacob }
1196 1.10 mjacob return (0);
1197 1.1 cgd }
1198 1.1 cgd }
1199 1.1 cgd
1200 1.1 cgd if (ISP_READ(isp, BIU_SEMA) & 1) {
1201 1.23 mjacob u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0);
1202 1.28 mjacob if (isp_parse_async(isp, (int) mbox))
1203 1.24 mjacob return (1);
1204 1.1 cgd ISP_WRITE(isp, BIU_SEMA, 0);
1205 1.1 cgd }
1206 1.1 cgd
1207 1.10 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
1208 1.25 mjacob
1209 1.24 mjacob optr = isp->isp_residx;
1210 1.10 mjacob iptr = ISP_READ(isp, OUTMAILBOX5);
1211 1.24 mjacob
1212 1.10 mjacob if (optr == iptr) {
1213 1.20 mjacob IDPRINTF(4, ("why intr? isr %x iptr %x optr %x\n",
1214 1.25 mjacob isr, optr, iptr));
1215 1.10 mjacob }
1216 1.10 mjacob ENABLE_INTS(isp);
1217 1.10 mjacob
1218 1.1 cgd while (optr != iptr) {
1219 1.1 cgd ispstatusreq_t *sp;
1220 1.25 mjacob u_int8_t oop;
1221 1.1 cgd int buddaboom = 0;
1222 1.1 cgd
1223 1.7 thorpej sp = (ispstatusreq_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
1224 1.25 mjacob oop = optr;
1225 1.25 mjacob optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN);
1226 1.1 cgd
1227 1.1 cgd if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) {
1228 1.25 mjacob if (isp_handle_other_response(isp, sp, &optr) == 0) {
1229 1.25 mjacob ISP_WRITE(isp, INMAILBOX5, optr);
1230 1.25 mjacob continue;
1231 1.25 mjacob }
1232 1.25 mjacob /*
1233 1.25 mjacob * It really has to be a bounced request just copied
1234 1.25 mjacob * from the request queue to the response queue.
1235 1.25 mjacob */
1236 1.25 mjacob
1237 1.1 cgd if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) {
1238 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
1239 1.1 cgd continue;
1240 1.1 cgd }
1241 1.25 mjacob PRINTF("%s: not RESPONSE in RESPONSE Queue "
1242 1.25 mjacob "(type 0x%x) @ idx %d (next %d)\n", isp->isp_name,
1243 1.25 mjacob sp->req_header.rqs_entry_type, oop, optr);
1244 1.1 cgd buddaboom = 1;
1245 1.1 cgd }
1246 1.1 cgd
1247 1.1 cgd if (sp->req_header.rqs_flags & 0xf) {
1248 1.1 cgd if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
1249 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
1250 1.1 cgd continue;
1251 1.1 cgd }
1252 1.23 mjacob PRINTF("%s: rqs_flags=%x", isp->isp_name,
1253 1.1 cgd sp->req_header.rqs_flags & 0xf);
1254 1.23 mjacob if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
1255 1.23 mjacob PRINTF("%s: internal queues full\n",
1256 1.23 mjacob isp->isp_name);
1257 1.23 mjacob /* XXXX: this command *could* get restarted */
1258 1.23 mjacob buddaboom++;
1259 1.23 mjacob }
1260 1.23 mjacob if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
1261 1.23 mjacob PRINTF("%s: bad header\n", isp->isp_name);
1262 1.23 mjacob buddaboom++;
1263 1.23 mjacob }
1264 1.23 mjacob if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
1265 1.23 mjacob PRINTF("%s: bad request packet\n",
1266 1.23 mjacob isp->isp_name);
1267 1.23 mjacob buddaboom++;
1268 1.23 mjacob }
1269 1.1 cgd }
1270 1.23 mjacob if (sp->req_handle > RQUEST_QUEUE_LEN || sp->req_handle < 1) {
1271 1.23 mjacob PRINTF("%s: bad request handle %d\n", isp->isp_name,
1272 1.1 cgd sp->req_handle);
1273 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
1274 1.1 cgd continue;
1275 1.1 cgd }
1276 1.23 mjacob xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[sp->req_handle - 1];
1277 1.1 cgd if (xs == NULL) {
1278 1.23 mjacob PRINTF("%s: NULL xs in xflist (handle %x)\n",
1279 1.23 mjacob isp->isp_name, sp->req_handle);
1280 1.23 mjacob isp_dumpxflist(isp);
1281 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
1282 1.1 cgd continue;
1283 1.1 cgd }
1284 1.10 mjacob isp->isp_xflist[sp->req_handle - 1] = NULL;
1285 1.1 cgd if (sp->req_status_flags & RQSTF_BUS_RESET) {
1286 1.1 cgd isp->isp_sendmarker = 1;
1287 1.1 cgd }
1288 1.1 cgd if (buddaboom) {
1289 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
1290 1.1 cgd }
1291 1.23 mjacob XS_STS(xs) = sp->req_scsi_status & 0xff;
1292 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
1293 1.10 mjacob if (sp->req_state_flags & RQSF_GOT_SENSE) {
1294 1.23 mjacob bcopy(sp->req_sense_data, XS_SNSP(xs),
1295 1.23 mjacob XS_SNSLEN(xs));
1296 1.23 mjacob XS_SNS_IS_VALID(xs);
1297 1.10 mjacob }
1298 1.10 mjacob } else {
1299 1.23 mjacob if (XS_STS(xs) == SCSI_CHECK) {
1300 1.23 mjacob XS_SNS_IS_VALID(xs);
1301 1.23 mjacob bcopy(sp->req_sense_data, XS_SNSP(xs),
1302 1.23 mjacob XS_SNSLEN(xs));
1303 1.10 mjacob sp->req_state_flags |= RQSF_GOT_SENSE;
1304 1.10 mjacob }
1305 1.1 cgd }
1306 1.23 mjacob if (XS_NOERR(xs) && XS_STS(xs) == SCSI_BUSY) {
1307 1.23 mjacob XS_SETERR(xs, HBA_TGTBSY);
1308 1.10 mjacob }
1309 1.1 cgd
1310 1.1 cgd if (sp->req_header.rqs_entry_type == RQSTYPE_RESPONSE) {
1311 1.25 mjacob if (XS_NOERR(xs)) {
1312 1.25 mjacob if (sp->req_completion_status != RQCS_COMPLETE) {
1313 1.23 mjacob isp_parse_status(isp, sp, xs);
1314 1.25 mjacob } else {
1315 1.25 mjacob XS_SETERR(xs, HBA_NOERROR);
1316 1.25 mjacob }
1317 1.25 mjacob }
1318 1.1 cgd } else {
1319 1.23 mjacob PRINTF("%s: unknown return %x\n", isp->isp_name,
1320 1.1 cgd sp->req_header.rqs_entry_type);
1321 1.23 mjacob if (XS_NOERR(xs))
1322 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
1323 1.1 cgd }
1324 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
1325 1.23 mjacob XS_RESID(xs) = sp->req_resid;
1326 1.10 mjacob } else if (sp->req_scsi_status & RQCS_RU) {
1327 1.23 mjacob XS_RESID(xs) = sp->req_resid;
1328 1.20 mjacob IDPRINTF(4, ("%s: cnt %d rsd %d\n", isp->isp_name,
1329 1.23 mjacob XS_XFRLEN(xs), sp->req_resid));
1330 1.10 mjacob }
1331 1.23 mjacob if (XS_XFRLEN(xs)) {
1332 1.10 mjacob ISP_DMAFREE(isp, xs, sp->req_handle - 1);
1333 1.1 cgd }
1334 1.23 mjacob /*
1335 1.23 mjacob * XXX: If we have a check condition, but no Sense Data,
1336 1.23 mjacob * XXX: mark it as an error (ARQ failed). We need to
1337 1.23 mjacob * XXX: to do a more distinct job because there may
1338 1.23 mjacob * XXX: cases where ARQ is disabled.
1339 1.23 mjacob */
1340 1.23 mjacob if (XS_STS(xs) == SCSI_CHECK && !(XS_IS_SNS_VALID(xs))) {
1341 1.23 mjacob if (XS_NOERR(xs)) {
1342 1.28 mjacob PRINTF("%s: ARQ failure for target %d lun %d\n",
1343 1.28 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
1344 1.23 mjacob XS_SETERR(xs, HBA_ARQFAIL);
1345 1.23 mjacob }
1346 1.23 mjacob }
1347 1.23 mjacob if ((isp->isp_dblev >= 5) ||
1348 1.23 mjacob (isp->isp_dblev > 2 && !XS_NOERR(xs))) {
1349 1.23 mjacob PRINTF("%s(%d.%d): FIN%d dl%d resid%d STS %x",
1350 1.23 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs),
1351 1.23 mjacob sp->req_header.rqs_seqno, XS_XFRLEN(xs),
1352 1.23 mjacob XS_RESID(xs), XS_STS(xs));
1353 1.10 mjacob if (sp->req_state_flags & RQSF_GOT_SENSE) {
1354 1.23 mjacob PRINTF(" Skey: %x", XS_SNSKEY(xs));
1355 1.23 mjacob if (!(XS_IS_SNS_VALID(xs))) {
1356 1.23 mjacob PRINTF(" BUT NOT SET");
1357 1.10 mjacob }
1358 1.1 cgd }
1359 1.27 mjacob PRINTF(" XS_ERR=0x%x\n", (unsigned int) XS_ERR(xs));
1360 1.1 cgd }
1361 1.23 mjacob
1362 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
1363 1.28 mjacob if (isp->isp_nactive > 0)
1364 1.28 mjacob isp->isp_nactive--;
1365 1.25 mjacob complist[ndone++] = xs; /* defer completion call until later */
1366 1.1 cgd }
1367 1.27 mjacob /*
1368 1.27 mjacob * If we completed any commands, then it's valid to find out
1369 1.27 mjacob * what the outpointer is.
1370 1.27 mjacob */
1371 1.27 mjacob if (ndone) {
1372 1.27 mjacob isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4);
1373 1.27 mjacob }
1374 1.1 cgd isp->isp_residx = optr;
1375 1.25 mjacob for (i = 0; i < ndone; i++) {
1376 1.25 mjacob xs = complist[i];
1377 1.25 mjacob if (xs) {
1378 1.25 mjacob XS_CMD_DONE(xs);
1379 1.25 mjacob }
1380 1.25 mjacob }
1381 1.1 cgd return (1);
1382 1.1 cgd }
1383 1.1 cgd
1384 1.1 cgd /*
1385 1.1 cgd * Support routines.
1386 1.1 cgd */
1387 1.1 cgd
1388 1.25 mjacob static int
1389 1.25 mjacob isp_parse_async(isp, mbox)
1390 1.25 mjacob struct ispsoftc *isp;
1391 1.28 mjacob int mbox;
1392 1.25 mjacob {
1393 1.25 mjacob switch (mbox) {
1394 1.25 mjacob case ASYNC_BUS_RESET:
1395 1.25 mjacob PRINTF("%s: SCSI bus reset detected\n", isp->isp_name);
1396 1.25 mjacob isp->isp_sendmarker = 1;
1397 1.29 mjacob #ifdef ISP_TARGET_MODE
1398 1.29 mjacob isp_notify_ack(isp, NULL);
1399 1.29 mjacob #endif
1400 1.25 mjacob break;
1401 1.25 mjacob
1402 1.25 mjacob case ASYNC_SYSTEM_ERROR:
1403 1.25 mjacob mbox = ISP_READ(isp, OUTMAILBOX1);
1404 1.25 mjacob PRINTF("%s: Internal FW Error @ RISC Addr 0x%x\n",
1405 1.25 mjacob isp->isp_name, mbox);
1406 1.25 mjacob isp_restart(isp);
1407 1.25 mjacob /* no point continuing after this */
1408 1.25 mjacob return (1);
1409 1.25 mjacob
1410 1.25 mjacob case ASYNC_RQS_XFER_ERR:
1411 1.25 mjacob PRINTF("%s: Request Queue Transfer Error\n", isp->isp_name);
1412 1.25 mjacob break;
1413 1.25 mjacob
1414 1.25 mjacob case ASYNC_RSP_XFER_ERR:
1415 1.25 mjacob PRINTF("%s: Response Queue Transfer Error\n", isp->isp_name);
1416 1.25 mjacob break;
1417 1.25 mjacob
1418 1.25 mjacob case ASYNC_QWAKEUP:
1419 1.25 mjacob /* don't need to be chatty */
1420 1.25 mjacob mbox = ISP_READ(isp, OUTMAILBOX4);
1421 1.25 mjacob break;
1422 1.25 mjacob
1423 1.25 mjacob case ASYNC_TIMEOUT_RESET:
1424 1.25 mjacob PRINTF("%s: timeout initiated SCSI bus reset\n", isp->isp_name);
1425 1.25 mjacob isp->isp_sendmarker = 1;
1426 1.29 mjacob #ifdef ISP_TARGET_MODE
1427 1.29 mjacob isp_notify_ack(isp, NULL);
1428 1.29 mjacob #endif
1429 1.25 mjacob break;
1430 1.25 mjacob
1431 1.28 mjacob case ASYNC_DEVICE_RESET:
1432 1.28 mjacob PRINTF("%s: device reset\n", isp->isp_name);
1433 1.29 mjacob #ifdef ISP_TARGET_MODE
1434 1.29 mjacob isp_notify_ack(isp, NULL);
1435 1.29 mjacob #endif
1436 1.25 mjacob break;
1437 1.25 mjacob
1438 1.25 mjacob case ASYNC_EXTMSG_UNDERRUN:
1439 1.25 mjacob PRINTF("%s: extended message underrun\n", isp->isp_name);
1440 1.25 mjacob break;
1441 1.25 mjacob
1442 1.25 mjacob case ASYNC_SCAM_INT:
1443 1.25 mjacob PRINTF("%s: SCAM interrupt\n", isp->isp_name);
1444 1.25 mjacob break;
1445 1.25 mjacob
1446 1.25 mjacob case ASYNC_HUNG_SCSI:
1447 1.25 mjacob PRINTF("%s: stalled SCSI Bus after DATA Overrun\n",
1448 1.25 mjacob isp->isp_name);
1449 1.25 mjacob /* XXX: Need to issue SCSI reset at this point */
1450 1.25 mjacob break;
1451 1.25 mjacob
1452 1.25 mjacob case ASYNC_KILLED_BUS:
1453 1.25 mjacob PRINTF("%s: SCSI Bus reset after DATA Overrun\n",
1454 1.25 mjacob isp->isp_name);
1455 1.25 mjacob break;
1456 1.25 mjacob
1457 1.25 mjacob case ASYNC_BUS_TRANSIT:
1458 1.25 mjacob PRINTF("%s: LBD->HVD Transition 0x%x\n",
1459 1.25 mjacob isp->isp_name, ISP_READ(isp, OUTMAILBOX1));
1460 1.25 mjacob break;
1461 1.25 mjacob
1462 1.25 mjacob case ASYNC_CMD_CMPLT:
1463 1.25 mjacob PRINTF("%s: fast post completion\n", isp->isp_name);
1464 1.25 mjacob #if 0
1465 1.25 mjacob fast_post_handle = (ISP_READ(isp, OUTMAILBOX1) << 16) |
1466 1.25 mjacob ISP_READ(isp, OUTMAILBOX2);
1467 1.25 mjacob #endif
1468 1.25 mjacob break;
1469 1.25 mjacob
1470 1.25 mjacob case ASYNC_CTIO_DONE:
1471 1.28 mjacob /* Should only occur when Fast Posting Set for 2100s */
1472 1.25 mjacob PRINTF("%s: CTIO done\n", isp->isp_name);
1473 1.25 mjacob break;
1474 1.25 mjacob
1475 1.25 mjacob case ASYNC_LIP_OCCURRED:
1476 1.25 mjacob PRINTF("%s: LIP occurred\n", isp->isp_name);
1477 1.25 mjacob break;
1478 1.25 mjacob
1479 1.25 mjacob case ASYNC_LOOP_UP:
1480 1.25 mjacob PRINTF("%s: Loop UP\n", isp->isp_name);
1481 1.25 mjacob break;
1482 1.25 mjacob
1483 1.25 mjacob case ASYNC_LOOP_DOWN:
1484 1.25 mjacob PRINTF("%s: Loop DOWN\n", isp->isp_name);
1485 1.25 mjacob break;
1486 1.25 mjacob
1487 1.25 mjacob case ASYNC_LOOP_RESET:
1488 1.25 mjacob PRINTF("%s: Loop RESET\n", isp->isp_name);
1489 1.29 mjacob #ifdef ISP_TARGET_MODE
1490 1.29 mjacob isp_notify_ack(isp, NULL);
1491 1.29 mjacob #endif
1492 1.25 mjacob break;
1493 1.25 mjacob
1494 1.25 mjacob case ASYNC_PDB_CHANGED:
1495 1.25 mjacob PRINTF("%s: Port Database Changed\n", isp->isp_name);
1496 1.25 mjacob break;
1497 1.25 mjacob
1498 1.25 mjacob case ASYNC_CHANGE_NOTIFY:
1499 1.25 mjacob PRINTF("%s: Name Server Database Changed\n", isp->isp_name);
1500 1.25 mjacob break;
1501 1.25 mjacob
1502 1.25 mjacob default:
1503 1.25 mjacob PRINTF("%s: async %x\n", isp->isp_name, mbox);
1504 1.25 mjacob break;
1505 1.25 mjacob }
1506 1.25 mjacob return (0);
1507 1.25 mjacob }
1508 1.25 mjacob
1509 1.25 mjacob static int
1510 1.25 mjacob isp_handle_other_response(isp, sp, optrp)
1511 1.25 mjacob struct ispsoftc *isp;
1512 1.25 mjacob ispstatusreq_t *sp;
1513 1.25 mjacob u_int8_t *optrp;
1514 1.25 mjacob {
1515 1.27 mjacob u_int8_t iptr, optr;
1516 1.27 mjacob int reqsize = 0;
1517 1.27 mjacob void *ireqp = NULL;
1518 1.29 mjacob #ifdef ISP_TARGET_MODE
1519 1.29 mjacob union {
1520 1.29 mjacob at_entry_t *atio;
1521 1.29 mjacob at2_entry_t *at2io;
1522 1.29 mjacob ct_entry_t *ctio;
1523 1.29 mjacob ct2_entry_t *ct2io;
1524 1.29 mjacob lun_entry_t *lunen;
1525 1.29 mjacob in_entry_t *inot;
1526 1.29 mjacob in_fcentry_t *inot_fc;
1527 1.29 mjacob na_entry_t *nack;
1528 1.29 mjacob na_fcentry_t *nack_fc;
1529 1.29 mjacob void *voidp;
1530 1.29 mjacob #define atio un.atio
1531 1.29 mjacob #define at2io un.at2io
1532 1.29 mjacob #define ctio un.ctio
1533 1.29 mjacob #define ct2io un.ct2io
1534 1.29 mjacob #define lunen un.lunen
1535 1.29 mjacob #define inot un.inot
1536 1.29 mjacob #define inot_fc un.inot_fc
1537 1.29 mjacob #define nack un.nack
1538 1.29 mjacob #define nack_fc un.nack_fc
1539 1.29 mjacob } un;
1540 1.29 mjacob
1541 1.29 mjacob un.voidp = sp;
1542 1.29 mjacob #endif
1543 1.27 mjacob
1544 1.28 mjacob
1545 1.25 mjacob switch (sp->req_header.rqs_entry_type) {
1546 1.27 mjacob case RQSTYPE_REQUEST:
1547 1.27 mjacob return (-1);
1548 1.29 mjacob #ifdef ISP_TARGET_MODE
1549 1.29 mjacob case RQSTYPE_NOTIFY_ACK:
1550 1.29 mjacob {
1551 1.29 mjacob static const char *f =
1552 1.29 mjacob "%s: Notify Ack Status 0x%x Sequence Id 0x%x\n"
1553 1.29 mjacob /*
1554 1.29 mjacob * The ISP is acknowleding our ack of an Immediate Notify.
1555 1.29 mjacob */
1556 1.29 mjacob if (isp->isp_type & ISP_HA_FC) {
1557 1.29 mjacob PRINTF(f, isp->isp_name,
1558 1.29 mjacob nack_fc->na-status, nack_fc->na_seqid);
1559 1.29 mjacob } else {
1560 1.29 mjacob PRINTF(f, isp->isp_name,
1561 1.29 mjacob nack->na_status, nack->na_seqid);
1562 1.29 mjacob }
1563 1.29 mjacob break;
1564 1.29 mjacob }
1565 1.29 mjacob case RQSTYPE_NOTIFY:
1566 1.29 mjacob {
1567 1.29 mjacob u_int16_t seqid, status;
1568 1.29 mjacob
1569 1.29 mjacob /*
1570 1.29 mjacob * Either the ISP received a SCSI message it cannot handle
1571 1.29 mjacob * or some other out of band condition (e.g., Port Logout)
1572 1.29 mjacob * or it is returning an Immediate Notify entry we sent.
1573 1.29 mjacob */
1574 1.29 mjacob if (isp->isp_type & ISP_HA_FC) {
1575 1.29 mjacob status = inot_fc->status;
1576 1.29 mjacob seqid = inot_fc->in_seqid;
1577 1.29 mjacob } else {
1578 1.29 mjacob status = inot->status;
1579 1.29 mjacob seqid = inot->seqid & 0xff;
1580 1.29 mjacob }
1581 1.29 mjacob PRINTF("%s: Immediate Notify Status 0x%x Sequence Id 0x%x\n",
1582 1.29 mjacob isp->isp_name, status, seqid);
1583 1.29 mjacob
1584 1.29 mjacob switch (status) {
1585 1.29 mjacob case IN_MSG_RECEIVED:
1586 1.29 mjacob case IN_IDE_RECEIVED:
1587 1.29 mjacob ptisp_got_msg(ptp, &inot);
1588 1.29 mjacob break;
1589 1.29 mjacob case IN_RSRC_UNAVAIL:
1590 1.29 mjacob PRINTF("%s: Firmware out of ATIOs\n", isp->isp_name);
1591 1.29 mjacob break;
1592 1.29 mjacob case IN_ABORT_TASK:
1593 1.29 mjacob PRINTF("%s: Abort Task iid %d rx_id 0x%x\n",
1594 1.29 mjacob inot_fc->in_iid, seqid);
1595 1.29 mjacob break;
1596 1.29 mjacob case IN_PORT_LOGOUT:
1597 1.29 mjacob PRINTF("%s: Port Logout for Initiator %d\n",
1598 1.29 mjacob isp->isp_name, inot_fc->in_iid);
1599 1.29 mjacob break;
1600 1.29 mjacob default:
1601 1.29 mjacob PRINTF("%s: bad status (0x%x) in Immediate Notify\n",
1602 1.29 mjacob isp->isp_name, status);
1603 1.29 mjacob break;
1604 1.29 mjacob
1605 1.29 mjacob }
1606 1.29 mjacob isp_notify_ack(isp, un.voidp);
1607 1.29 mjacob reqsize = 0;
1608 1.29 mjacob break;
1609 1.29 mjacob }
1610 1.29 mjacob case RQSTYPE_ENABLE_LUN:
1611 1.29 mjacob case RQSTYPE_MODIFY_LUN:
1612 1.29 mjacob if (lunen->req_status != 1) {
1613 1.29 mjacob PRINTF("%s: ENABLE/MODIFY LUN returned status 0x%x\n",
1614 1.29 mjacob isp->isp_name, lunen->req_status);
1615 1.29 mjacob }
1616 1.29 mjacob break;
1617 1.29 mjacob case RQSTYPE_ATIO2:
1618 1.29 mjacob {
1619 1.29 mjacob fcparam *fcp = isp->isp_param;
1620 1.29 mjacob ispctiot2_t local, *ct2 = NULL;
1621 1.29 mjacob ispatiot2_t *at2 = (ispatiot2_t *) sp;
1622 1.29 mjacob int s, lun;
1623 1.29 mjacob
1624 1.29 mjacob #ifdef SCCLUN
1625 1.29 mjacob lun = at2->req_scclun;
1626 1.29 mjacob #else
1627 1.29 mjacob lun = at2->req_lun;
1628 1.29 mjacob #endif
1629 1.29 mjacob PRINTF("%s: atio2 loopid %d for lun %d rxid 0x%x flags0x%x "
1630 1.29 mjacob "tflags0x%x ecodes0x%x rqstatus0x%x\n", isp->isp_name,
1631 1.29 mjacob at2->req_initiator, lun, at2->req_rxid,
1632 1.29 mjacob at2->req_flags, at2->req_taskflags, at2->req_execodes,
1633 1.29 mjacob at2->req_status);
1634 1.29 mjacob
1635 1.29 mjacob switch (at2->req_status & ~ATIO_SENSEVALID) {
1636 1.29 mjacob case ATIO_PATH_INVALID:
1637 1.29 mjacob PRINTF("%s: ATIO2 Path Invalid\n", isp->isp_name);
1638 1.29 mjacob break;
1639 1.29 mjacob case ATIO_NOCAP:
1640 1.29 mjacob PRINTF("%s: ATIO2 No Cap\n", isp->isp_name);
1641 1.29 mjacob break;
1642 1.29 mjacob case ATIO_BDR_MSG:
1643 1.29 mjacob PRINTF("%s: ATIO2 BDR Received\n", isp->isp_name);
1644 1.29 mjacob break;
1645 1.29 mjacob case ATIO_CDB_RECEIVED:
1646 1.29 mjacob ct2 = &local;
1647 1.29 mjacob break;
1648 1.29 mjacob default:
1649 1.29 mjacob PRINTF("%s: unknown req_status 0x%x\n", isp->isp_name,
1650 1.29 mjacob at2->req_status);
1651 1.29 mjacob break;
1652 1.29 mjacob }
1653 1.29 mjacob if (ct2 == NULL) {
1654 1.29 mjacob /*
1655 1.29 mjacob * Just do an ACCEPT on this fellow.
1656 1.29 mjacob */
1657 1.29 mjacob at2->req_header.rqs_entry_type = RQSTYPE_ATIO2;
1658 1.29 mjacob at2->req_header.rqs_flags = 0;
1659 1.29 mjacob at2->req_flags = 1;
1660 1.29 mjacob ireqp = at2;
1661 1.29 mjacob reqsize = sizeof (*at2);
1662 1.29 mjacob break;
1663 1.29 mjacob }
1664 1.29 mjacob PRINTF("%s: datalen %d cdb0=0x%x\n", isp->isp_name,
1665 1.29 mjacob at2->req_datalen, at2->req_cdb[0]);
1666 1.29 mjacob bzero ((void *) ct2, sizeof (*ct2));
1667 1.29 mjacob ct2->req_header.rqs_entry_type = RQSTYPE_CTIO2;
1668 1.29 mjacob ct2->req_header.rqs_entry_count = 1;
1669 1.29 mjacob ct2->req_header.rqs_flags = 0;
1670 1.29 mjacob ct2->req_header.rqs_seqno = isp->isp_seqno++;
1671 1.29 mjacob ct2->req_handle = (at2->req_initiator << 16) | lun;
1672 1.29 mjacob #ifndef SCCLUN
1673 1.29 mjacob ct2->req_lun = lun;
1674 1.29 mjacob #endif
1675 1.29 mjacob ct2->req_initiator = at2->req_initiator;
1676 1.29 mjacob ct2->req_rxid = at2->req_rxid;
1677 1.29 mjacob
1678 1.29 mjacob ct2->req_flags = CTIO_SEND_STATUS;
1679 1.29 mjacob switch (at2->req_cdb[0]) {
1680 1.29 mjacob case 0x0: /* TUR */
1681 1.29 mjacob ct2->req_flags |= CTIO_NODATA | CTIO2_SMODE0;
1682 1.29 mjacob ct2->req_m.mode0.req_scsi_status = CTIO2_STATUS_VALID;
1683 1.29 mjacob break;
1684 1.29 mjacob
1685 1.29 mjacob case 0x3: /* REQUEST SENSE */
1686 1.29 mjacob case 0x12: /* INQUIRE */
1687 1.29 mjacob ct2->req_flags |= CTIO_SEND_DATA | CTIO2_SMODE0;
1688 1.29 mjacob ct2->req_m.mode0.req_scsi_status = CTIO2_STATUS_VALID;
1689 1.29 mjacob ct2->req_seg_count = 1;
1690 1.29 mjacob if (at2->req_cdb[0] == 0x12) {
1691 1.29 mjacob s = sizeof(tgtiqd);
1692 1.29 mjacob bcopy((void *)tgtiqd, fcp->isp_scratch, s);
1693 1.29 mjacob } else {
1694 1.29 mjacob s = at2->req_datalen;
1695 1.29 mjacob bzero(fcp->isp_scratch, s);
1696 1.29 mjacob }
1697 1.29 mjacob ct2->req_m.mode0.req_dataseg[0].ds_base =
1698 1.29 mjacob fcp->isp_scdma;
1699 1.29 mjacob ct2->req_m.mode0.req_dataseg[0].ds_count = s;
1700 1.29 mjacob ct2->req_m.mode0.req_datalen = s;
1701 1.29 mjacob #if 1
1702 1.29 mjacob if (at2->req_datalen < s) {
1703 1.29 mjacob ct2->req_m.mode1.req_scsi_status |=
1704 1.29 mjacob CTIO2_RESP_VALID|CTIO2_RSPOVERUN;
1705 1.29 mjacob } else if (at2->req_datalen > s) {
1706 1.29 mjacob ct2->req_m.mode1.req_scsi_status |=
1707 1.29 mjacob CTIO2_RESP_VALID|CTIO2_RSPUNDERUN;
1708 1.29 mjacob }
1709 1.29 mjacob #endif
1710 1.29 mjacob break;
1711 1.29 mjacob
1712 1.29 mjacob default: /* ALL OTHERS */
1713 1.29 mjacob ct2->req_flags |= CTIO_NODATA | CTIO2_SMODE1;
1714 1.29 mjacob ct2->req_m.mode1.req_scsi_status = 0;
1715 1.29 mjacob #if 1
1716 1.29 mjacob if (at2->req_datalen) {
1717 1.29 mjacob ct2->req_m.mode1.req_scsi_status |=
1718 1.29 mjacob CTIO2_RSPUNDERUN;
1719 1.29 mjacob #if BYTE_ORDER == BIG_ENDIAN
1720 1.29 mjacob ct2->req_resid[1] = at2->req_datalen & 0xff;
1721 1.29 mjacob ct2->req_resid[0] =
1722 1.29 mjacob (at2->req_datalen >> 8) & 0xff;
1723 1.29 mjacob ct2->req_resid[3] =
1724 1.29 mjacob (at2->req_datalen >> 16) & 0xff;
1725 1.29 mjacob ct2->req_resid[2] =
1726 1.29 mjacob (at2->req_datalen >> 24) & 0xff;
1727 1.29 mjacob #else
1728 1.29 mjacob ct2->req_resid[0] = at2->req_datalen & 0xff;
1729 1.29 mjacob ct2->req_resid[1] =
1730 1.29 mjacob (at2->req_datalen >> 8) & 0xff;
1731 1.29 mjacob ct2->req_resid[2] =
1732 1.29 mjacob (at2->req_datalen >> 16) & 0xff;
1733 1.29 mjacob ct2->req_resid[3] =
1734 1.29 mjacob (at2->req_datalen >> 24) & 0xff;
1735 1.29 mjacob #endif
1736 1.29 mjacob }
1737 1.29 mjacob #endif
1738 1.29 mjacob if ((at2->req_status & ATIO_SENSEVALID) == 0) {
1739 1.29 mjacob ct2->req_m.mode1.req_sense_len = 18;
1740 1.29 mjacob ct2->req_m.mode1.req_scsi_status |= 2;
1741 1.29 mjacob ct2->req_m.mode1.req_response[0] = 0x70;
1742 1.29 mjacob ct2->req_m.mode1.req_response[2] = 0x2;
1743 1.29 mjacob } else {
1744 1.29 mjacob ct2->req_m.mode1.req_sense_len = 18;
1745 1.29 mjacob ct2->req_m.mode1.req_scsi_status |=
1746 1.29 mjacob at2->req_scsi_status;
1747 1.29 mjacob bcopy((void *)at2->req_sense,
1748 1.29 mjacob (void *)ct2->req_m.mode1.req_response,
1749 1.29 mjacob sizeof (at2->req_sense));
1750 1.29 mjacob }
1751 1.29 mjacob break;
1752 1.29 mjacob }
1753 1.29 mjacob reqsize = sizeof (*ct2);
1754 1.29 mjacob ireqp = ct2;
1755 1.29 mjacob break;
1756 1.29 mjacob }
1757 1.29 mjacob case RQSTYPE_CTIO2:
1758 1.29 mjacob {
1759 1.29 mjacob ispatiot2_t *at2;
1760 1.29 mjacob ispctiot2_t *ct2 = (ispctiot2_t *) sp;
1761 1.29 mjacob PRINTF("%s: CTIO2 returned status 0x%x\n", isp->isp_name,
1762 1.29 mjacob ct2->req_status);
1763 1.29 mjacob /*
1764 1.29 mjacob * Return the ATIO to the board.
1765 1.29 mjacob */
1766 1.29 mjacob at2 = (ispatiot2_t *) sp;
1767 1.29 mjacob at2->req_header.rqs_entry_type = RQSTYPE_ATIO2;
1768 1.29 mjacob at2->req_header.rqs_entry_count = 1;
1769 1.29 mjacob at2->req_header.rqs_flags = 0;
1770 1.29 mjacob at2->req_header.rqs_seqno = isp->isp_seqno++;
1771 1.29 mjacob at2->req_status = 1;
1772 1.29 mjacob reqsize = sizeof (*at2);
1773 1.29 mjacob ireqp = at2;
1774 1.29 mjacob break;
1775 1.29 mjacob }
1776 1.29 mjacob #undef atio
1777 1.29 mjacob #undef at2io
1778 1.29 mjacob #undef ctio
1779 1.29 mjacob #undef ct2io
1780 1.29 mjacob #undef lunen
1781 1.29 mjacob #undef inot
1782 1.29 mjacob #undef inot_fc
1783 1.29 mjacob #undef nack
1784 1.29 mjacob #undef nack_fc
1785 1.29 mjacob #endif
1786 1.25 mjacob default:
1787 1.25 mjacob PRINTF("%s: other response type %x\n", isp->isp_name,
1788 1.25 mjacob sp->req_header.rqs_entry_type);
1789 1.25 mjacob break;
1790 1.25 mjacob }
1791 1.27 mjacob if (reqsize) {
1792 1.27 mjacob void *reqp;
1793 1.27 mjacob optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4);
1794 1.27 mjacob iptr = isp->isp_reqidx;
1795 1.27 mjacob reqp = (void *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
1796 1.27 mjacob iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN);
1797 1.27 mjacob if (iptr == optr) {
1798 1.27 mjacob PRINTF("%s: Request Queue Overflow other response\n",
1799 1.27 mjacob isp->isp_name);
1800 1.27 mjacob } else {
1801 1.27 mjacob bcopy(ireqp, reqp, reqsize);
1802 1.27 mjacob ISP_WRITE(isp, INMAILBOX4, iptr);
1803 1.27 mjacob isp->isp_reqidx = iptr;
1804 1.27 mjacob }
1805 1.27 mjacob }
1806 1.25 mjacob return (0);
1807 1.25 mjacob }
1808 1.25 mjacob
1809 1.29 mjacob #ifdef ISP_TARGET_MODE
1810 1.29 mjacob
1811 1.29 mjacob static void isp_tmd_newcmd_dflt __P((void *, tmd_cmd_t *));
1812 1.29 mjacob static void isp_tmd_event_dflt __P((void *, int));
1813 1.29 mjacob static void isp_tmd_notify_dflt __P((void *, tmd_notify_t *));
1814 1.29 mjacob
1815 1.29 mjacob static void isp_tgt_data_xfer __P ((tmd_cmd_t *));
1816 1.29 mjacob static void isp_tgt_endcmd __P ((tmd_cmd_t *, u_int8_t));
1817 1.29 mjacob static void isp_tgt_done __P ((tmd_cmd_t *));
1818 1.29 mjacob
1819 1.29 mjacob static void
1820 1.29 mjacob isp_tmd_newcmd_dflt(arg0, cmdp)
1821 1.29 mjacob void *arg0;
1822 1.29 mjacob tmd_cmd_t *cmdp;
1823 1.29 mjacob {
1824 1.29 mjacob }
1825 1.29 mjacob
1826 1.29 mjacob static void
1827 1.29 mjacob isp_tmd_event_dflt(arg0, event)
1828 1.29 mjacob void *arg0;
1829 1.29 mjacob int event;
1830 1.29 mjacob {
1831 1.29 mjacob }
1832 1.29 mjacob
1833 1.29 mjacob static void
1834 1.29 mjacob isp_tmd_notify_dflt(arg0, npt)
1835 1.29 mjacob void *arg0;
1836 1.29 mjacob tmd_notify_t *npt;
1837 1.29 mjacob {
1838 1.29 mjacob }
1839 1.29 mjacob
1840 1.29 mjacob /*
1841 1.29 mjacob * Locks held, and ints disabled (if FC).
1842 1.29 mjacob *
1843 1.29 mjacob * XXX: SETUP ONLY FOR INITIAL ENABLING RIGHT NOW
1844 1.29 mjacob */
1845 1.29 mjacob static int
1846 1.29 mjacob isp_modify_lun(isp, lun, icnt, ccnt)
1847 1.29 mjacob struct ispsoftc *isp;
1848 1.29 mjacob int lun; /* logical unit to enable, modify, or disable */
1849 1.29 mjacob int icnt; /* immediate notify count */
1850 1.29 mjacob int ccnt; /* command count */
1851 1.29 mjacob {
1852 1.29 mjacob isplun_t *ip = NULL;
1853 1.29 mjacob u_int8_t iptr, optr;
1854 1.29 mjacob
1855 1.29 mjacob optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4);
1856 1.29 mjacob iptr = isp->isp_reqidx;
1857 1.29 mjacob ip = (isplun_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
1858 1.29 mjacob iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN);
1859 1.29 mjacob if (iptr == optr) {
1860 1.29 mjacob PRINTF("%s: Request Queue Overflow in isp_modify_lun\n",
1861 1.29 mjacob isp->isp_name);
1862 1.29 mjacob return (-1);
1863 1.29 mjacob }
1864 1.29 mjacob
1865 1.29 mjacob bzero((void *) ip, sizeof (*ip));
1866 1.29 mjacob ip->req_header.rqs_entry_type = RQSTYPE_ENABLE_LUN;
1867 1.29 mjacob ip->req_header.rqs_entry_count = 1;
1868 1.29 mjacob ip->req_header.rqs_seqno = isp->isp_seqno++;
1869 1.29 mjacob ip->req_handle = RQSTYPE_ENABLE_LUN;
1870 1.29 mjacob if (isp->isp_type & ISP_HA_SCSI) {
1871 1.29 mjacob ip->req_lun = lun;
1872 1.29 mjacob }
1873 1.29 mjacob ip->req_cmdcount = ccnt;
1874 1.29 mjacob ip->req_imcount = icnt;
1875 1.29 mjacob ip->req_timeout = 0; /* default 30 seconds */
1876 1.29 mjacob ISP_WRITE(isp, INMAILBOX4, iptr);
1877 1.29 mjacob isp->isp_reqidx = iptr;
1878 1.29 mjacob return (0);
1879 1.29 mjacob }
1880 1.29 mjacob
1881 1.29 mjacob static void
1882 1.29 mjacob isp_notify_ack(isp, ptrp)
1883 1.29 mjacob struct ispsoftc *isp;
1884 1.29 mjacob void *ptrp;
1885 1.29 mjacob {
1886 1.29 mjacob void *reqp;
1887 1.29 mjacob u_int8_t iptr, optr;
1888 1.29 mjacob union {
1889 1.29 mjacob na_fcentry_t _naf;
1890 1.29 mjacob na_entry_t _nas;
1891 1.29 mjacob } un;
1892 1.29 mjacob
1893 1.29 mjacob bzero((caddr_t)&un, sizeof (un));
1894 1.29 mjacob un._nas.na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
1895 1.29 mjacob un._nas.na_header.rqs_entry_count = 1;
1896 1.29 mjacob
1897 1.29 mjacob if (isp->isp_type & ISP_HA_FC) {
1898 1.29 mjacob na_fcentry_t *na = &un._nas;
1899 1.29 mjacob if (ptrp) {
1900 1.29 mjacob in_fcentry_t *inp = ptrp;
1901 1.29 mjacob na->na_iid = inp->in_iid;
1902 1.29 mjacob na->na_lun = inp->in_lun;
1903 1.29 mjacob na->na_task_flags = inp->in_task_flags;
1904 1.29 mjacob na->na_seqid = inp->in_seqid;
1905 1.29 mjacob na->na_status = inp->in_status;
1906 1.29 mjacob } else {
1907 1.29 mjacob na->na_flags = NAFC_RST_CLRD;
1908 1.29 mjacob }
1909 1.29 mjacob } else {
1910 1.29 mjacob na_entry_t *na = &un._nas;
1911 1.29 mjacob if (ptrp) {
1912 1.29 mjacob in_entry_t *inp = ptrp;
1913 1.29 mjacob na->na_iid = inp->in_iid;
1914 1.29 mjacob na->na_lun = inp->in_lun;
1915 1.29 mjacob na->na_tgt = inp->in_tgt;
1916 1.29 mjacob na->na_seqid = inp->in_seqid;
1917 1.29 mjacob } else {
1918 1.29 mjacob na->na_flags = NA_RST_CLRD;
1919 1.29 mjacob }
1920 1.29 mjacob }
1921 1.29 mjacob optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4);
1922 1.29 mjacob iptr = isp->isp_reqidx;
1923 1.29 mjacob reqp = (void *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
1924 1.29 mjacob iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN);
1925 1.29 mjacob if (iptr == optr) {
1926 1.29 mjacob PRINTF("%s: Request Queue Overflow For isp_notify_ack\n",
1927 1.29 mjacob isp->isp_name);
1928 1.29 mjacob } else {
1929 1.29 mjacob bcopy(ireqp, reqp, sizeof (un));
1930 1.29 mjacob ISP_WRITE(isp, INMAILBOX4, iptr);
1931 1.29 mjacob isp->isp_reqidx = iptr;
1932 1.29 mjacob }
1933 1.29 mjacob }
1934 1.29 mjacob
1935 1.29 mjacob /*
1936 1.29 mjacob * These are dummy stubs for now until the outside framework is plugged in.
1937 1.29 mjacob */
1938 1.29 mjacob
1939 1.29 mjacob static void
1940 1.29 mjacob isp_handle_atio (isp, aep)
1941 1.29 mjacob struct ispsoftc *isp;
1942 1.29 mjacob at_entry_t *aep;
1943 1.29 mjacob {
1944 1.29 mjacob int status, connected;
1945 1.29 mjacob tmd_cmd_t local, *cdp = &local;
1946 1.29 mjacob
1947 1.29 mjacob /*
1948 1.29 mjacob * Get the ATIO status and see if we're still connected.
1949 1.29 mjacob */
1950 1.29 mjacob status = aep->at_status;
1951 1.29 mjacob connected = ((aep->at_flags & AT_NODISC) != 0);
1952 1.29 mjacob
1953 1.29 mjacob PRINTF("%s: ATIO status=0x%x, connected=%d\n", isp->isp_name,
1954 1.29 mjacob status, connected);
1955 1.29 mjacob
1956 1.29 mjacob /*
1957 1.29 mjacob * The firmware status (except for the SenseValid bit) indicates
1958 1.29 mjacob * why this ATIO was sent to us.
1959 1.29 mjacob * If SenseValid is set, the firware has recommended Sense Data.
1960 1.29 mjacob * If the Disconnects Disabled bit is set in the flags field,
1961 1.29 mjacob * we're still connected on the SCSI bus - i.e. the initiator
1962 1.29 mjacob * did not set DiscPriv in the identify message. We don't care
1963 1.29 mjacob * about this so it's ignored.
1964 1.29 mjacob */
1965 1.29 mjacob switch(status & ~TGTSVALID) {
1966 1.29 mjacob case AT_PATH_INVALID:
1967 1.29 mjacob /*
1968 1.29 mjacob * ATIO rejected by the firmware due to disabled lun.
1969 1.29 mjacob */
1970 1.29 mjacob PRINTF("%s: Firmware rejected ATIO for disabled lun %d\n",
1971 1.29 mjacob isp->isp_name, aep->at_lun);
1972 1.29 mjacob break;
1973 1.29 mjacob
1974 1.29 mjacob case AT_PHASE_ERROR:
1975 1.29 mjacob /*
1976 1.29 mjacob * Bus Pase Sequence error.
1977 1.29 mjacob *
1978 1.29 mjacob * The firmware should have filled in the correct
1979 1.29 mjacob * sense data.
1980 1.29 mjacob */
1981 1.29 mjacob
1982 1.29 mjacob
1983 1.29 mjacob if (status & TGTSVALID) {
1984 1.29 mjacob bcopy((caddr_t) aep->at_sense,
1985 1.29 mjacob (caddr_t) &cdp->cd_sensedata,
1986 1.29 mjacob sizeof (cdp->cd_sensedata));
1987 1.29 mjacob PRINTF("%s: Bus Phase Sequence error key 0x%x\n",
1988 1.29 mjacob isp->isp_name, cdp->cd_sensedata[2] & 0xf);
1989 1.29 mjacob } else {
1990 1.29 mjacob PRINTF("%s: Bus Phase Sequence With No Sense\n",
1991 1.29 mjacob isp->isp_name);
1992 1.29 mjacob }
1993 1.29 mjacob (*isp->isp_tmd_newcmd)(isp, cdp);
1994 1.29 mjacob break;
1995 1.29 mjacob
1996 1.29 mjacob case AT_NOCAP:
1997 1.29 mjacob /*
1998 1.29 mjacob * Requested Capability not available
1999 1.29 mjacob * We sent an ATIO that overflowed the firmware's
2000 1.29 mjacob * command resource count.
2001 1.29 mjacob */
2002 1.29 mjacob PRINTF("%s: Firmware rejected ATIO, command count overflow\n",
2003 1.29 mjacob isp->isp_name);
2004 1.29 mjacob break;
2005 1.29 mjacob
2006 1.29 mjacob case AT_BDR_MSG:
2007 1.29 mjacob /*
2008 1.29 mjacob * If we send an ATIO to the firmware to increment
2009 1.29 mjacob * its command resource count, and the firmware is
2010 1.29 mjacob * recovering from a Bus Device Reset, it returns
2011 1.29 mjacob * the ATIO with this status.
2012 1.29 mjacob */
2013 1.29 mjacob PRINTF("%s: ATIO returned with BDR received\n", isp->isp_name);
2014 1.29 mjacob break;
2015 1.29 mjacob
2016 1.29 mjacob case AT_CDB:
2017 1.29 mjacob /*
2018 1.29 mjacob * New CDB
2019 1.29 mjacob */
2020 1.29 mjacob cdp->cd_hba = isp;
2021 1.29 mjacob cdp->cd_iid = aep->at_iid;
2022 1.29 mjacob cdp->cd_tgt = aep->at_tgt;
2023 1.29 mjacob cdp->cd_lun = aep->at_lun;
2024 1.29 mjacob cdp->cd_tagtype = aep->at_tag_type;
2025 1.29 mjacob cdp->cd_tagval = aep->at_tag_val;
2026 1.29 mjacob bcopy(aep->at_cdb, cdp->cd_cdb, 16);
2027 1.29 mjacob PRINTF("%s: CDB 0x%x itl %d/%d/%d\n", isp->isp_name,
2028 1.29 mjacob cdp->cd_cdb[0], cdp->cd_iid, cdp->cd_tgt, cdp->cd_lun);
2029 1.29 mjacob (*isp->isp_tmd_newcmd)(isp, cdp);
2030 1.29 mjacob break;
2031 1.29 mjacob
2032 1.29 mjacob default:
2033 1.29 mjacob PRINTF("%s: Unknown status (0x%x) in ATIO\n",
2034 1.29 mjacob isp->isp_name, status);
2035 1.29 mjacob cdp->cd_hba = isp;
2036 1.29 mjacob cdp->cd_iid = aep->at_iid;
2037 1.29 mjacob cdp->cd_tgt = aep->at_tgt;
2038 1.29 mjacob cdp->cd_lun = aep->at_lun;
2039 1.29 mjacob cdp->cd_tagtype = aep->at_tag_type;
2040 1.29 mjacob cdp->cd_tagval = aep->at_tag_val;
2041 1.29 mjacob isp_tgtcmd_done(cdp);
2042 1.29 mjacob break;
2043 1.29 mjacob }
2044 1.29 mjacob }
2045 1.29 mjacob
2046 1.29 mjacob static void
2047 1.29 mjacob isp_handle_atio2(isp, aep)
2048 1.29 mjacob struct ispsoftc *isp;
2049 1.29 mjacob at2_entry_t *aep;
2050 1.29 mjacob {
2051 1.29 mjacob int status;
2052 1.29 mjacob tmd_cmd_t local, *cdp = &local;
2053 1.29 mjacob
2054 1.29 mjacob /*
2055 1.29 mjacob * Get the ATIO2 status.
2056 1.29 mjacob */
2057 1.29 mjacob status = aep->at_status;
2058 1.29 mjacob PRINTD("%s: ATIO2 status=0x%x\n", status);
2059 1.29 mjacob
2060 1.29 mjacob /*
2061 1.29 mjacob * The firmware status (except for the SenseValid bit) indicates
2062 1.29 mjacob * why this ATIO was sent to us.
2063 1.29 mjacob * If SenseValid is set, the firware has recommended Sense Data.
2064 1.29 mjacob */
2065 1.29 mjacob switch(status & ~TGTSVALID) {
2066 1.29 mjacob case AT_PATH_INVALID:
2067 1.29 mjacob /*
2068 1.29 mjacob * ATIO rejected by the firmware due to disabled lun.
2069 1.29 mjacob */
2070 1.29 mjacob PRINTF("%s: Firmware rejected ATIO2 for disabled lun %d\n",
2071 1.29 mjacob isp->isp_name, aep->at_lun);
2072 1.29 mjacob break;
2073 1.29 mjacob
2074 1.29 mjacob case AT_NOCAP:
2075 1.29 mjacob /*
2076 1.29 mjacob * Requested Capability not available
2077 1.29 mjacob * We sent an ATIO that overflowed the firmware's
2078 1.29 mjacob * command resource count.
2079 1.29 mjacob */
2080 1.29 mjacob PRINTF("%s: Firmware rejected ATIO2, command count overflow\n",
2081 1.29 mjacob isp->isp_name);
2082 1.29 mjacob break;
2083 1.29 mjacob
2084 1.29 mjacob case AT_BDR_MSG:
2085 1.29 mjacob /*
2086 1.29 mjacob * If we send an ATIO to the firmware to increment
2087 1.29 mjacob * its command resource count, and the firmware is
2088 1.29 mjacob * recovering from a Bus Device Reset, it returns
2089 1.29 mjacob * the ATIO with this status.
2090 1.29 mjacob */
2091 1.29 mjacob PRINTF("%s: ATIO2 returned with BDR rcvd\n", isp->isp_name);
2092 1.29 mjacob break;
2093 1.29 mjacob
2094 1.29 mjacob case AT_CDB:
2095 1.29 mjacob /*
2096 1.29 mjacob * New CDB
2097 1.29 mjacob */
2098 1.29 mjacob cdp->cd_hba = isp;
2099 1.29 mjacob cdp->cd_iid = aep->at_iid;
2100 1.29 mjacob cdp->cd_tgt = 0;
2101 1.29 mjacob cdp->cd_lun = aep->at_lun;
2102 1.29 mjacob bcopy(aep->at_cdb, cdp->cd_cdb, 16);
2103 1.29 mjacob cdp->cd_rxid = aep->at_rxid;
2104 1.29 mjacob cdp->cp_origdlen = aep->at_datalen;
2105 1.29 mjacob cdp->cp_totbytes = 0;
2106 1.29 mjacob PRINTF("%s: CDB 0x%x rx_id 0x%x itl %d/%d/%d dlen %d\n",
2107 1.29 mjacob isp->isp_name, cdp->cd_cdb[0], cdp->cd_tagval, cdp->cd_iid,
2108 1.29 mjacob cdp->cd_tgt, cdp->cd_lun, aep->at_datalen);
2109 1.29 mjacob (*isp->isp_tmd_newcmd)(isp, cdp);
2110 1.29 mjacob break;
2111 1.29 mjacob
2112 1.29 mjacob default:
2113 1.29 mjacob PRINTF("%s: Unknown status (0x%x) in ATIO2\n",
2114 1.29 mjacob isp->isp_name, status);
2115 1.29 mjacob cdp->cd_hba = isp;
2116 1.29 mjacob cdp->cd_iid = aep->at_iid;
2117 1.29 mjacob cdp->cd_tgt = aep->at_tgt;
2118 1.29 mjacob cdp->cd_lun = aep->at_lun;
2119 1.29 mjacob cdp->cp_rxid = aep->at_rxid;
2120 1.29 mjacob isp_tgtcmd_done(cdp);
2121 1.29 mjacob break;
2122 1.29 mjacob }
2123 1.29 mjacob }
2124 1.29 mjacob
2125 1.29 mjacob static void
2126 1.29 mjacob isp_handle_ctio(isp, cep)
2127 1.29 mjacob struct ispsoftc *isp;
2128 1.29 mjacob ct_entry_t *aep;
2129 1.29 mjacob {
2130 1.29 mjacob }
2131 1.29 mjacob
2132 1.29 mjacob static void
2133 1.29 mjacob isp_handle_ctio2(isp, cep)
2134 1.29 mjacob struct ispsoftc *isp;
2135 1.29 mjacob at2_entry_t *aep;
2136 1.29 mjacob {
2137 1.29 mjacob }
2138 1.29 mjacob #endif
2139 1.25 mjacob
2140 1.23 mjacob static void
2141 1.10 mjacob isp_parse_status(isp, sp, xs)
2142 1.1 cgd struct ispsoftc *isp;
2143 1.1 cgd ispstatusreq_t *sp;
2144 1.23 mjacob ISP_SCSI_XFER_T *xs;
2145 1.1 cgd {
2146 1.1 cgd switch (sp->req_completion_status) {
2147 1.1 cgd case RQCS_COMPLETE:
2148 1.23 mjacob XS_SETERR(xs, HBA_NOERROR);
2149 1.23 mjacob return;
2150 1.10 mjacob
2151 1.1 cgd case RQCS_INCOMPLETE:
2152 1.1 cgd if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
2153 1.27 mjacob IDPRINTF(3, ("%s: Selection Timeout for target %d\n",
2154 1.27 mjacob isp->isp_name, XS_TGT(xs)));
2155 1.23 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
2156 1.23 mjacob return;
2157 1.1 cgd }
2158 1.25 mjacob PRINTF("%s: command incomplete for target %d lun %d, state "
2159 1.25 mjacob "0x%x\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs),
2160 1.25 mjacob sp->req_state_flags);
2161 1.25 mjacob break;
2162 1.25 mjacob
2163 1.25 mjacob case RQCS_DMA_ERROR:
2164 1.25 mjacob PRINTF("%s: DMA error for command on target %d, lun %d\n",
2165 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2166 1.1 cgd break;
2167 1.15 mjacob
2168 1.15 mjacob case RQCS_TRANSPORT_ERROR:
2169 1.23 mjacob PRINTF("%s: transport error\n", isp->isp_name);
2170 1.15 mjacob isp_prtstst(sp);
2171 1.15 mjacob break;
2172 1.15 mjacob
2173 1.25 mjacob case RQCS_RESET_OCCURRED:
2174 1.25 mjacob IDPRINTF(2, ("%s: bus reset destroyed command for target %d "
2175 1.25 mjacob "lun %d\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)));
2176 1.25 mjacob isp->isp_sendmarker = 1;
2177 1.25 mjacob XS_SETERR(xs, HBA_BUSRESET);
2178 1.25 mjacob return;
2179 1.25 mjacob
2180 1.25 mjacob case RQCS_ABORTED:
2181 1.25 mjacob PRINTF("%s: command aborted for target %d lun %d\n",
2182 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2183 1.25 mjacob isp->isp_sendmarker = 1;
2184 1.25 mjacob XS_SETERR(xs, HBA_ABORTED);
2185 1.25 mjacob return;
2186 1.25 mjacob
2187 1.25 mjacob case RQCS_TIMEOUT:
2188 1.25 mjacob IDPRINTF(2, ("%s: command timed out for target %d lun %d\n",
2189 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs)));
2190 1.25 mjacob XS_SETERR(xs, HBA_CMDTIMEOUT);
2191 1.25 mjacob return;
2192 1.25 mjacob
2193 1.10 mjacob case RQCS_DATA_OVERRUN:
2194 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
2195 1.23 mjacob XS_RESID(xs) = sp->req_resid;
2196 1.10 mjacob break;
2197 1.10 mjacob }
2198 1.23 mjacob XS_SETERR(xs, HBA_DATAOVR);
2199 1.23 mjacob return;
2200 1.10 mjacob
2201 1.25 mjacob case RQCS_COMMAND_OVERRUN:
2202 1.25 mjacob PRINTF("%s: command overrun for command on target %d, lun %d\n",
2203 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2204 1.25 mjacob break;
2205 1.25 mjacob
2206 1.25 mjacob case RQCS_STATUS_OVERRUN:
2207 1.25 mjacob PRINTF("%s: status overrun for command on target %d, lun %d\n",
2208 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2209 1.25 mjacob break;
2210 1.25 mjacob
2211 1.25 mjacob case RQCS_BAD_MESSAGE:
2212 1.25 mjacob PRINTF("%s: message not COMMAND COMPLETE after status on "
2213 1.25 mjacob "target %d, lun %d\n", isp->isp_name, XS_TGT(xs),
2214 1.25 mjacob XS_LUN(xs));
2215 1.25 mjacob break;
2216 1.25 mjacob
2217 1.25 mjacob case RQCS_NO_MESSAGE_OUT:
2218 1.25 mjacob PRINTF("%s: No MESSAGE OUT phase after selection on "
2219 1.25 mjacob "target %d, lun %d\n", isp->isp_name, XS_TGT(xs),
2220 1.25 mjacob XS_LUN(xs));
2221 1.25 mjacob break;
2222 1.25 mjacob
2223 1.25 mjacob case RQCS_EXT_ID_FAILED:
2224 1.25 mjacob PRINTF("%s: EXTENDED IDENTIFY failed on target %d, lun %d\n",
2225 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2226 1.25 mjacob break;
2227 1.25 mjacob
2228 1.25 mjacob case RQCS_IDE_MSG_FAILED:
2229 1.25 mjacob PRINTF("%s: target %d lun %d rejected INITIATOR DETECTED "
2230 1.25 mjacob "ERROR message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2231 1.25 mjacob break;
2232 1.25 mjacob
2233 1.25 mjacob case RQCS_ABORT_MSG_FAILED:
2234 1.25 mjacob PRINTF("%s: target %d lun %d rejected ABORT message\n",
2235 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2236 1.25 mjacob break;
2237 1.25 mjacob
2238 1.25 mjacob case RQCS_REJECT_MSG_FAILED:
2239 1.25 mjacob PRINTF("%s: target %d lun %d rejected MESSAGE REJECT message\n",
2240 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2241 1.25 mjacob break;
2242 1.25 mjacob
2243 1.25 mjacob case RQCS_NOP_MSG_FAILED:
2244 1.25 mjacob PRINTF("%s: target %d lun %d rejected NOP message\n",
2245 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2246 1.25 mjacob break;
2247 1.25 mjacob
2248 1.25 mjacob case RQCS_PARITY_ERROR_MSG_FAILED:
2249 1.25 mjacob PRINTF("%s: target %d lun %d rejected MESSAGE PARITY ERROR "
2250 1.25 mjacob "message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2251 1.25 mjacob break;
2252 1.25 mjacob
2253 1.25 mjacob case RQCS_DEVICE_RESET_MSG_FAILED:
2254 1.25 mjacob PRINTF("%s: target %d lun %d rejected BUS DEVICE RESET "
2255 1.25 mjacob "message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2256 1.25 mjacob break;
2257 1.25 mjacob
2258 1.25 mjacob case RQCS_ID_MSG_FAILED:
2259 1.25 mjacob PRINTF("%s: target %d lun %d rejected IDENTIFY "
2260 1.25 mjacob "message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2261 1.25 mjacob break;
2262 1.25 mjacob
2263 1.25 mjacob case RQCS_UNEXP_BUS_FREE:
2264 1.28 mjacob PRINTF("%s: target %d lun %d had an unexpected bus free\n",
2265 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2266 1.25 mjacob break;
2267 1.25 mjacob
2268 1.1 cgd case RQCS_DATA_UNDERRUN:
2269 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
2270 1.23 mjacob XS_RESID(xs) = sp->req_resid;
2271 1.23 mjacob /* an UNDERRUN is not a botch ??? */
2272 1.10 mjacob }
2273 1.23 mjacob XS_SETERR(xs, HBA_NOERROR);
2274 1.23 mjacob return;
2275 1.10 mjacob
2276 1.25 mjacob case RQCS_XACT_ERR1:
2277 1.25 mjacob PRINTF("%s: HBA attempted queued transaction with disconnect "
2278 1.25 mjacob "not set for target %d lun %d\n", isp->isp_name, XS_TGT(xs),
2279 1.25 mjacob XS_LUN(xs));
2280 1.25 mjacob break;
2281 1.25 mjacob
2282 1.25 mjacob case RQCS_XACT_ERR2:
2283 1.25 mjacob PRINTF("%s: HBA attempted queued transaction to target "
2284 1.25 mjacob "routine %d on target %d\n", isp->isp_name, XS_LUN(xs),
2285 1.25 mjacob XS_TGT(xs));
2286 1.25 mjacob break;
2287 1.25 mjacob
2288 1.25 mjacob case RQCS_XACT_ERR3:
2289 1.25 mjacob PRINTF("%s: HBA attempted queued transaction for target %d lun "
2290 1.25 mjacob "%d when queueing disabled\n", isp->isp_name, XS_TGT(xs),
2291 1.25 mjacob XS_LUN(xs));
2292 1.25 mjacob break;
2293 1.25 mjacob
2294 1.25 mjacob case RQCS_BAD_ENTRY:
2295 1.25 mjacob PRINTF("%s: invalid IOCB entry type detected\n", isp->isp_name);
2296 1.25 mjacob break;
2297 1.25 mjacob
2298 1.25 mjacob case RQCS_QUEUE_FULL:
2299 1.27 mjacob PRINTF("%s: internal queues full for target %d lun %d\n",
2300 1.27 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2301 1.25 mjacob break;
2302 1.25 mjacob
2303 1.25 mjacob case RQCS_PHASE_SKIPPED:
2304 1.25 mjacob PRINTF("%s: SCSI phase skipped (e.g., COMMAND COMPLETE w/o "
2305 1.25 mjacob "STATUS phase) for target %d lun %d\n", isp->isp_name,
2306 1.25 mjacob XS_TGT(xs), XS_LUN(xs));
2307 1.25 mjacob break;
2308 1.25 mjacob
2309 1.25 mjacob case RQCS_ARQS_FAILED:
2310 1.25 mjacob PRINTF("%s: Auto Request Sense failed for target %d lun %d\n",
2311 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2312 1.25 mjacob XS_SETERR(xs, HBA_ARQFAIL);
2313 1.23 mjacob return;
2314 1.10 mjacob
2315 1.25 mjacob case RQCS_WIDE_FAILED:
2316 1.25 mjacob PRINTF("%s: Wide Negotiation failed for target %d lun %d\n",
2317 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2318 1.25 mjacob if (isp->isp_type & ISP_HA_SCSI) {
2319 1.25 mjacob sdparam *sdp = isp->isp_param;
2320 1.25 mjacob isp->isp_update = 1;
2321 1.25 mjacob sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
2322 1.25 mjacob sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_WIDE;
2323 1.25 mjacob }
2324 1.25 mjacob XS_SETERR(xs, HBA_NOERROR);
2325 1.23 mjacob return;
2326 1.10 mjacob
2327 1.25 mjacob case RQCS_SYNCXFER_FAILED:
2328 1.25 mjacob PRINTF("%s: SDTR Message failed for target %d lun %d\n",
2329 1.25 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2330 1.25 mjacob if (isp->isp_type & ISP_HA_SCSI) {
2331 1.25 mjacob sdparam *sdp = isp->isp_param;
2332 1.25 mjacob isp->isp_update = 1;
2333 1.25 mjacob sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
2334 1.25 mjacob sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_SYNC;
2335 1.25 mjacob }
2336 1.25 mjacob break;
2337 1.25 mjacob
2338 1.25 mjacob case RQCS_LVD_BUSERR:
2339 1.25 mjacob PRINTF("%s: Bad LVD Bus condition while talking to target %d "
2340 1.25 mjacob "lun %d\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs));
2341 1.25 mjacob break;
2342 1.10 mjacob
2343 1.10 mjacob case RQCS_PORT_UNAVAILABLE:
2344 1.10 mjacob /*
2345 1.10 mjacob * No such port on the loop. Moral equivalent of SELTIMEO
2346 1.10 mjacob */
2347 1.27 mjacob IDPRINTF(3, ("%s: Port Unavailable for target %d\n",
2348 1.27 mjacob isp->isp_name, XS_TGT(xs)));
2349 1.23 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
2350 1.23 mjacob return;
2351 1.10 mjacob
2352 1.10 mjacob case RQCS_PORT_LOGGED_OUT:
2353 1.27 mjacob /*
2354 1.27 mjacob * It was there (maybe)- treat as a selection timeout.
2355 1.27 mjacob */
2356 1.23 mjacob PRINTF("%s: port logout for target %d\n",
2357 1.23 mjacob isp->isp_name, XS_TGT(xs));
2358 1.27 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
2359 1.27 mjacob return;
2360 1.10 mjacob
2361 1.10 mjacob case RQCS_PORT_CHANGED:
2362 1.23 mjacob PRINTF("%s: port changed for target %d\n",
2363 1.23 mjacob isp->isp_name, XS_TGT(xs));
2364 1.10 mjacob break;
2365 1.10 mjacob
2366 1.10 mjacob case RQCS_PORT_BUSY:
2367 1.23 mjacob PRINTF("%s: port busy for target %d\n",
2368 1.23 mjacob isp->isp_name, XS_TGT(xs));
2369 1.23 mjacob XS_SETERR(xs, HBA_TGTBSY);
2370 1.23 mjacob return;
2371 1.10 mjacob
2372 1.1 cgd default:
2373 1.23 mjacob PRINTF("%s: comp status %x\n", isp->isp_name,
2374 1.1 cgd sp->req_completion_status);
2375 1.1 cgd break;
2376 1.1 cgd }
2377 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
2378 1.1 cgd }
2379 1.1 cgd
2380 1.1 cgd #define HINIB(x) ((x) >> 0x4)
2381 1.1 cgd #define LONIB(x) ((x) & 0xf)
2382 1.1 cgd #define MAKNIB(a, b) (((a) << 4) | (b))
2383 1.1 cgd static u_int8_t mbpcnt[] = {
2384 1.10 mjacob MAKNIB(1, 1), /* 0x00: MBOX_NO_OP */
2385 1.10 mjacob MAKNIB(5, 5), /* 0x01: MBOX_LOAD_RAM */
2386 1.10 mjacob MAKNIB(2, 0), /* 0x02: MBOX_EXEC_FIRMWARE */
2387 1.10 mjacob MAKNIB(5, 5), /* 0x03: MBOX_DUMP_RAM */
2388 1.10 mjacob MAKNIB(3, 3), /* 0x04: MBOX_WRITE_RAM_WORD */
2389 1.10 mjacob MAKNIB(2, 3), /* 0x05: MBOX_READ_RAM_WORD */
2390 1.10 mjacob MAKNIB(6, 6), /* 0x06: MBOX_MAILBOX_REG_TEST */
2391 1.10 mjacob MAKNIB(2, 3), /* 0x07: MBOX_VERIFY_CHECKSUM */
2392 1.10 mjacob MAKNIB(1, 3), /* 0x08: MBOX_ABOUT_FIRMWARE */
2393 1.10 mjacob MAKNIB(0, 0), /* 0x09: */
2394 1.10 mjacob MAKNIB(0, 0), /* 0x0a: */
2395 1.10 mjacob MAKNIB(0, 0), /* 0x0b: */
2396 1.10 mjacob MAKNIB(0, 0), /* 0x0c: */
2397 1.10 mjacob MAKNIB(0, 0), /* 0x0d: */
2398 1.10 mjacob MAKNIB(1, 2), /* 0x0e: MBOX_CHECK_FIRMWARE */
2399 1.10 mjacob MAKNIB(0, 0), /* 0x0f: */
2400 1.10 mjacob MAKNIB(5, 5), /* 0x10: MBOX_INIT_REQ_QUEUE */
2401 1.10 mjacob MAKNIB(6, 6), /* 0x11: MBOX_INIT_RES_QUEUE */
2402 1.10 mjacob MAKNIB(4, 4), /* 0x12: MBOX_EXECUTE_IOCB */
2403 1.10 mjacob MAKNIB(2, 2), /* 0x13: MBOX_WAKE_UP */
2404 1.10 mjacob MAKNIB(1, 6), /* 0x14: MBOX_STOP_FIRMWARE */
2405 1.10 mjacob MAKNIB(4, 4), /* 0x15: MBOX_ABORT */
2406 1.10 mjacob MAKNIB(2, 2), /* 0x16: MBOX_ABORT_DEVICE */
2407 1.10 mjacob MAKNIB(3, 3), /* 0x17: MBOX_ABORT_TARGET */
2408 1.10 mjacob MAKNIB(2, 2), /* 0x18: MBOX_BUS_RESET */
2409 1.10 mjacob MAKNIB(2, 3), /* 0x19: MBOX_STOP_QUEUE */
2410 1.10 mjacob MAKNIB(2, 3), /* 0x1a: MBOX_START_QUEUE */
2411 1.10 mjacob MAKNIB(2, 3), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
2412 1.10 mjacob MAKNIB(2, 3), /* 0x1c: MBOX_ABORT_QUEUE */
2413 1.10 mjacob MAKNIB(2, 4), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
2414 1.10 mjacob MAKNIB(0, 0), /* 0x1e: */
2415 1.10 mjacob MAKNIB(1, 3), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
2416 1.27 mjacob MAKNIB(1, 3), /* 0x20: MBOX_GET_INIT_SCSI_ID, MBOX_GET_LOOP_ID */
2417 1.10 mjacob MAKNIB(1, 2), /* 0x21: MBOX_GET_SELECT_TIMEOUT */
2418 1.10 mjacob MAKNIB(1, 3), /* 0x22: MBOX_GET_RETRY_COUNT */
2419 1.10 mjacob MAKNIB(1, 2), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
2420 1.10 mjacob MAKNIB(1, 2), /* 0x24: MBOX_GET_CLOCK_RATE */
2421 1.10 mjacob MAKNIB(1, 2), /* 0x25: MBOX_GET_ACT_NEG_STATE */
2422 1.10 mjacob MAKNIB(1, 2), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
2423 1.10 mjacob MAKNIB(1, 3), /* 0x27: MBOX_GET_PCI_PARAMS */
2424 1.10 mjacob MAKNIB(2, 4), /* 0x28: MBOX_GET_TARGET_PARAMS */
2425 1.10 mjacob MAKNIB(2, 4), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
2426 1.10 mjacob MAKNIB(0, 0), /* 0x2a: */
2427 1.10 mjacob MAKNIB(0, 0), /* 0x2b: */
2428 1.10 mjacob MAKNIB(0, 0), /* 0x2c: */
2429 1.10 mjacob MAKNIB(0, 0), /* 0x2d: */
2430 1.10 mjacob MAKNIB(0, 0), /* 0x2e: */
2431 1.10 mjacob MAKNIB(0, 0), /* 0x2f: */
2432 1.10 mjacob MAKNIB(2, 2), /* 0x30: MBOX_SET_INIT_SCSI_ID */
2433 1.10 mjacob MAKNIB(2, 2), /* 0x31: MBOX_SET_SELECT_TIMEOUT */
2434 1.10 mjacob MAKNIB(3, 3), /* 0x32: MBOX_SET_RETRY_COUNT */
2435 1.10 mjacob MAKNIB(2, 2), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
2436 1.10 mjacob MAKNIB(2, 2), /* 0x34: MBOX_SET_CLOCK_RATE */
2437 1.10 mjacob MAKNIB(2, 2), /* 0x35: MBOX_SET_ACTIVE_NEG_STATE */
2438 1.10 mjacob MAKNIB(2, 2), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
2439 1.10 mjacob MAKNIB(3, 3), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
2440 1.10 mjacob MAKNIB(4, 4), /* 0x38: MBOX_SET_TARGET_PARAMS */
2441 1.10 mjacob MAKNIB(4, 4), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
2442 1.10 mjacob MAKNIB(0, 0), /* 0x3a: */
2443 1.10 mjacob MAKNIB(0, 0), /* 0x3b: */
2444 1.10 mjacob MAKNIB(0, 0), /* 0x3c: */
2445 1.10 mjacob MAKNIB(0, 0), /* 0x3d: */
2446 1.10 mjacob MAKNIB(0, 0), /* 0x3e: */
2447 1.10 mjacob MAKNIB(0, 0), /* 0x3f: */
2448 1.10 mjacob MAKNIB(1, 2), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
2449 1.10 mjacob MAKNIB(6, 1), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
2450 1.10 mjacob MAKNIB(2, 3), /* 0x42: MBOX_EXEC_BIOS_IOCB */
2451 1.10 mjacob MAKNIB(0, 0), /* 0x43: */
2452 1.10 mjacob MAKNIB(0, 0), /* 0x44: */
2453 1.10 mjacob MAKNIB(0, 0), /* 0x45: */
2454 1.10 mjacob MAKNIB(0, 0), /* 0x46: */
2455 1.10 mjacob MAKNIB(0, 0), /* 0x47: */
2456 1.10 mjacob MAKNIB(0, 0), /* 0x48: */
2457 1.10 mjacob MAKNIB(0, 0), /* 0x49: */
2458 1.10 mjacob MAKNIB(0, 0), /* 0x4a: */
2459 1.10 mjacob MAKNIB(0, 0), /* 0x4b: */
2460 1.10 mjacob MAKNIB(0, 0), /* 0x4c: */
2461 1.10 mjacob MAKNIB(0, 0), /* 0x4d: */
2462 1.10 mjacob MAKNIB(0, 0), /* 0x4e: */
2463 1.10 mjacob MAKNIB(0, 0), /* 0x4f: */
2464 1.10 mjacob MAKNIB(0, 0), /* 0x50: */
2465 1.10 mjacob MAKNIB(0, 0), /* 0x51: */
2466 1.10 mjacob MAKNIB(0, 0), /* 0x52: */
2467 1.10 mjacob MAKNIB(0, 0), /* 0x53: */
2468 1.10 mjacob MAKNIB(8, 0), /* 0x54: MBOX_EXEC_COMMAND_IOCB_A64 */
2469 1.10 mjacob MAKNIB(0, 0), /* 0x55: */
2470 1.10 mjacob MAKNIB(0, 0), /* 0x56: */
2471 1.10 mjacob MAKNIB(0, 0), /* 0x57: */
2472 1.10 mjacob MAKNIB(0, 0), /* 0x58: */
2473 1.10 mjacob MAKNIB(0, 0), /* 0x59: */
2474 1.10 mjacob MAKNIB(0, 0), /* 0x5a: */
2475 1.10 mjacob MAKNIB(0, 0), /* 0x5b: */
2476 1.10 mjacob MAKNIB(0, 0), /* 0x5c: */
2477 1.10 mjacob MAKNIB(0, 0), /* 0x5d: */
2478 1.10 mjacob MAKNIB(0, 0), /* 0x5e: */
2479 1.10 mjacob MAKNIB(0, 0), /* 0x5f: */
2480 1.10 mjacob MAKNIB(8, 6), /* 0x60: MBOX_INIT_FIRMWARE */
2481 1.10 mjacob MAKNIB(0, 0), /* 0x60: MBOX_GET_INIT_CONTROL_BLOCK (FORMAT?) */
2482 1.10 mjacob MAKNIB(2, 1), /* 0x62: MBOX_INIT_LIP */
2483 1.10 mjacob MAKNIB(8, 1), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
2484 1.10 mjacob MAKNIB(8, 1), /* 0x64: MBOX_GET_PORT_DB */
2485 1.10 mjacob MAKNIB(3, 1), /* 0x65: MBOX_CLEAR_ACA */
2486 1.10 mjacob MAKNIB(3, 1), /* 0x66: MBOX_TARGET_RESET */
2487 1.10 mjacob MAKNIB(3, 1), /* 0x67: MBOX_CLEAR_TASK_SET */
2488 1.10 mjacob MAKNIB(3, 1), /* 0x69: MBOX_ABORT_TASK_SET */
2489 1.13 mjacob MAKNIB(1, 2) /* 0x69: MBOX_GET_FW_STATE */
2490 1.1 cgd };
2491 1.1 cgd #define NMBCOM (sizeof (mbpcnt) / sizeof (mbpcnt[0]))
2492 1.1 cgd
2493 1.10 mjacob static void
2494 1.1 cgd isp_mboxcmd(isp, mbp)
2495 1.1 cgd struct ispsoftc *isp;
2496 1.1 cgd mbreg_t *mbp;
2497 1.1 cgd {
2498 1.1 cgd int outparam, inparam;
2499 1.24 mjacob int loops, dld = 0;
2500 1.10 mjacob u_int8_t opcode;
2501 1.1 cgd
2502 1.10 mjacob if (mbp->param[0] == ISP2100_SET_PCI_PARAM) {
2503 1.10 mjacob opcode = mbp->param[0] = MBOX_SET_PCI_PARAMETERS;
2504 1.10 mjacob inparam = 4;
2505 1.10 mjacob outparam = 4;
2506 1.10 mjacob goto command_known;
2507 1.10 mjacob } else if (mbp->param[0] > NMBCOM) {
2508 1.23 mjacob PRINTF("%s: bad command %x\n", isp->isp_name, mbp->param[0]);
2509 1.10 mjacob return;
2510 1.1 cgd }
2511 1.1 cgd
2512 1.10 mjacob opcode = mbp->param[0];
2513 1.1 cgd inparam = HINIB(mbpcnt[mbp->param[0]]);
2514 1.1 cgd outparam = LONIB(mbpcnt[mbp->param[0]]);
2515 1.10 mjacob
2516 1.1 cgd if (inparam == 0 && outparam == 0) {
2517 1.23 mjacob PRINTF("%s: no parameters for %x\n", isp->isp_name,
2518 1.1 cgd mbp->param[0]);
2519 1.10 mjacob return;
2520 1.1 cgd }
2521 1.1 cgd
2522 1.10 mjacob
2523 1.28 mjacob /*
2524 1.28 mjacob * Check for variants
2525 1.28 mjacob */
2526 1.28 mjacob #ifdef SCCLUN
2527 1.28 mjacob if (isp->isp_type & ISP_HA_FC) {
2528 1.28 mjacob switch (mbp->param[0]) {
2529 1.28 mjacob case MBOX_ABORT:
2530 1.28 mjacob inparam = 7;
2531 1.28 mjacob break;
2532 1.28 mjacob case MBOX_ABORT_DEVICE:
2533 1.28 mjacob case MBOX_START_QUEUE:
2534 1.28 mjacob case MBOX_STOP_QUEUE:
2535 1.28 mjacob case MBOX_SINGLE_STEP_QUEUE:
2536 1.28 mjacob case MBOX_ABORT_QUEUE:
2537 1.28 mjacob case MBOX_GET_DEV_QUEUE_STATUS:
2538 1.28 mjacob inparam = 3;
2539 1.28 mjacob break;
2540 1.28 mjacob default:
2541 1.28 mjacob break;
2542 1.28 mjacob }
2543 1.28 mjacob }
2544 1.28 mjacob #endif
2545 1.28 mjacob
2546 1.10 mjacob command_known:
2547 1.24 mjacob
2548 1.1 cgd /*
2549 1.1 cgd * Make sure we can send some words..
2550 1.1 cgd */
2551 1.1 cgd
2552 1.1 cgd loops = MBOX_DELAY_COUNT;
2553 1.1 cgd while ((ISP_READ(isp, HCCR) & HCCR_HOST_INT) != 0) {
2554 1.23 mjacob SYS_DELAY(100);
2555 1.1 cgd if (--loops < 0) {
2556 1.23 mjacob PRINTF("%s: isp_mboxcmd timeout #1\n", isp->isp_name);
2557 1.24 mjacob if (dld++) {
2558 1.24 mjacob return;
2559 1.24 mjacob }
2560 1.24 mjacob PRINTF("%s: but we'll try again, isr=%x\n",
2561 1.24 mjacob isp->isp_name, ISP_READ(isp, BIU_ISR));
2562 1.24 mjacob if (ISP_READ(isp, BIU_SEMA) & 1) {
2563 1.24 mjacob u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0);
2564 1.28 mjacob if (isp_parse_async(isp, (int) mbox))
2565 1.25 mjacob return;
2566 1.24 mjacob ISP_WRITE(isp, BIU_SEMA, 0);
2567 1.24 mjacob }
2568 1.24 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
2569 1.24 mjacob goto command_known;
2570 1.1 cgd }
2571 1.1 cgd }
2572 1.1 cgd
2573 1.1 cgd /*
2574 1.1 cgd * Write input parameters
2575 1.1 cgd */
2576 1.1 cgd switch (inparam) {
2577 1.10 mjacob case 8: ISP_WRITE(isp, INMAILBOX7, mbp->param[7]); mbp->param[7] = 0;
2578 1.10 mjacob case 7: ISP_WRITE(isp, INMAILBOX6, mbp->param[6]); mbp->param[6] = 0;
2579 1.1 cgd case 6: ISP_WRITE(isp, INMAILBOX5, mbp->param[5]); mbp->param[5] = 0;
2580 1.1 cgd case 5: ISP_WRITE(isp, INMAILBOX4, mbp->param[4]); mbp->param[4] = 0;
2581 1.1 cgd case 4: ISP_WRITE(isp, INMAILBOX3, mbp->param[3]); mbp->param[3] = 0;
2582 1.1 cgd case 3: ISP_WRITE(isp, INMAILBOX2, mbp->param[2]); mbp->param[2] = 0;
2583 1.1 cgd case 2: ISP_WRITE(isp, INMAILBOX1, mbp->param[1]); mbp->param[1] = 0;
2584 1.1 cgd case 1: ISP_WRITE(isp, INMAILBOX0, mbp->param[0]); mbp->param[0] = 0;
2585 1.1 cgd }
2586 1.1 cgd
2587 1.1 cgd /*
2588 1.1 cgd * Clear semaphore on mailbox registers
2589 1.1 cgd */
2590 1.1 cgd ISP_WRITE(isp, BIU_SEMA, 0);
2591 1.1 cgd
2592 1.1 cgd /*
2593 1.1 cgd * Clear RISC int condition.
2594 1.1 cgd */
2595 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
2596 1.1 cgd
2597 1.1 cgd /*
2598 1.1 cgd * Set Host Interrupt condition so that RISC will pick up mailbox regs.
2599 1.1 cgd */
2600 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
2601 1.1 cgd
2602 1.1 cgd /*
2603 1.10 mjacob * Wait until RISC int is set, except 2100
2604 1.1 cgd */
2605 1.10 mjacob if ((isp->isp_type & ISP_HA_FC) == 0) {
2606 1.10 mjacob loops = MBOX_DELAY_COUNT;
2607 1.10 mjacob while ((ISP_READ(isp, BIU_ISR) & BIU_ISR_RISC_INT) == 0) {
2608 1.23 mjacob SYS_DELAY(100);
2609 1.10 mjacob if (--loops < 0) {
2610 1.23 mjacob PRINTF("%s: isp_mboxcmd timeout #2\n",
2611 1.10 mjacob isp->isp_name);
2612 1.10 mjacob return;
2613 1.10 mjacob }
2614 1.1 cgd }
2615 1.1 cgd }
2616 1.1 cgd
2617 1.1 cgd /*
2618 1.1 cgd * Check to make sure that the semaphore has been set.
2619 1.1 cgd */
2620 1.1 cgd loops = MBOX_DELAY_COUNT;
2621 1.1 cgd while ((ISP_READ(isp, BIU_SEMA) & 1) == 0) {
2622 1.23 mjacob SYS_DELAY(100);
2623 1.1 cgd if (--loops < 0) {
2624 1.23 mjacob PRINTF("%s: isp_mboxcmd timeout #3\n", isp->isp_name);
2625 1.10 mjacob return;
2626 1.1 cgd }
2627 1.1 cgd }
2628 1.1 cgd
2629 1.1 cgd /*
2630 1.1 cgd * Make sure that the MBOX_BUSY has gone away
2631 1.1 cgd */
2632 1.1 cgd loops = MBOX_DELAY_COUNT;
2633 1.1 cgd while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
2634 1.23 mjacob SYS_DELAY(100);
2635 1.1 cgd if (--loops < 0) {
2636 1.23 mjacob PRINTF("%s: isp_mboxcmd timeout #4\n", isp->isp_name);
2637 1.10 mjacob return;
2638 1.1 cgd }
2639 1.1 cgd }
2640 1.1 cgd
2641 1.1 cgd
2642 1.1 cgd /*
2643 1.1 cgd * Pick up output parameters.
2644 1.1 cgd */
2645 1.1 cgd switch (outparam) {
2646 1.10 mjacob case 8: mbp->param[7] = ISP_READ(isp, OUTMAILBOX7);
2647 1.10 mjacob case 7: mbp->param[6] = ISP_READ(isp, OUTMAILBOX6);
2648 1.1 cgd case 6: mbp->param[5] = ISP_READ(isp, OUTMAILBOX5);
2649 1.1 cgd case 5: mbp->param[4] = ISP_READ(isp, OUTMAILBOX4);
2650 1.1 cgd case 4: mbp->param[3] = ISP_READ(isp, OUTMAILBOX3);
2651 1.1 cgd case 3: mbp->param[2] = ISP_READ(isp, OUTMAILBOX2);
2652 1.1 cgd case 2: mbp->param[1] = ISP_READ(isp, OUTMAILBOX1);
2653 1.1 cgd case 1: mbp->param[0] = ISP_READ(isp, OUTMAILBOX0);
2654 1.1 cgd }
2655 1.1 cgd
2656 1.1 cgd /*
2657 1.1 cgd * Clear RISC int.
2658 1.1 cgd */
2659 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
2660 1.1 cgd
2661 1.1 cgd /*
2662 1.1 cgd * Release semaphore on mailbox registers
2663 1.1 cgd */
2664 1.1 cgd ISP_WRITE(isp, BIU_SEMA, 0);
2665 1.10 mjacob
2666 1.10 mjacob /*
2667 1.10 mjacob * Just to be chatty here...
2668 1.10 mjacob */
2669 1.10 mjacob switch(mbp->param[0]) {
2670 1.10 mjacob case MBOX_COMMAND_COMPLETE:
2671 1.10 mjacob break;
2672 1.10 mjacob case MBOX_INVALID_COMMAND:
2673 1.25 mjacob IDPRINTF(2, ("%s: mbox cmd %x failed with INVALID_COMMAND\n",
2674 1.25 mjacob isp->isp_name, opcode));
2675 1.10 mjacob break;
2676 1.10 mjacob case MBOX_HOST_INTERFACE_ERROR:
2677 1.23 mjacob PRINTF("%s: mbox cmd %x failed with HOST_INTERFACE_ERROR\n",
2678 1.25 mjacob isp->isp_name, opcode);
2679 1.10 mjacob break;
2680 1.10 mjacob case MBOX_TEST_FAILED:
2681 1.23 mjacob PRINTF("%s: mbox cmd %x failed with TEST_FAILED\n",
2682 1.25 mjacob isp->isp_name, opcode);
2683 1.10 mjacob break;
2684 1.10 mjacob case MBOX_COMMAND_ERROR:
2685 1.23 mjacob PRINTF("%s: mbox cmd %x failed with COMMAND_ERROR\n",
2686 1.25 mjacob isp->isp_name, opcode);
2687 1.10 mjacob break;
2688 1.10 mjacob case MBOX_COMMAND_PARAM_ERROR:
2689 1.23 mjacob PRINTF("%s: mbox cmd %x failed with COMMAND_PARAM_ERROR\n",
2690 1.25 mjacob isp->isp_name, opcode);
2691 1.10 mjacob break;
2692 1.10 mjacob
2693 1.28 mjacob /*
2694 1.28 mjacob * Be silent about these...
2695 1.28 mjacob */
2696 1.28 mjacob
2697 1.25 mjacob case ASYNC_LOOP_UP:
2698 1.10 mjacob case ASYNC_LIP_OCCURRED:
2699 1.28 mjacob case ASYNC_PDB_CHANGED:
2700 1.10 mjacob break;
2701 1.10 mjacob
2702 1.10 mjacob default:
2703 1.10 mjacob /*
2704 1.10 mjacob * The expected return of EXEC_FIRMWARE is zero.
2705 1.10 mjacob */
2706 1.10 mjacob if ((opcode == MBOX_EXEC_FIRMWARE && mbp->param[0] != 0) ||
2707 1.10 mjacob (opcode != MBOX_EXEC_FIRMWARE)) {
2708 1.23 mjacob PRINTF("%s: mbox cmd %x failed with error %x\n",
2709 1.10 mjacob isp->isp_name, opcode, mbp->param[0]);
2710 1.10 mjacob }
2711 1.10 mjacob break;
2712 1.10 mjacob }
2713 1.4 mjacob }
2714 1.4 mjacob
2715 1.23 mjacob void
2716 1.25 mjacob isp_lostcmd(isp, xs)
2717 1.25 mjacob struct ispsoftc *isp;
2718 1.25 mjacob ISP_SCSI_XFER_T *xs;
2719 1.4 mjacob {
2720 1.4 mjacob mbreg_t mbs;
2721 1.10 mjacob
2722 1.4 mjacob mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
2723 1.10 mjacob isp_mboxcmd(isp, &mbs);
2724 1.4 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2725 1.10 mjacob isp_dumpregs(isp, "couldn't GET FIRMWARE STATUS");
2726 1.4 mjacob return;
2727 1.4 mjacob }
2728 1.10 mjacob if (mbs.param[1]) {
2729 1.23 mjacob PRINTF("%s: %d commands on completion queue\n",
2730 1.10 mjacob isp->isp_name, mbs.param[1]);
2731 1.10 mjacob }
2732 1.23 mjacob if (XS_NULL(xs))
2733 1.4 mjacob return;
2734 1.4 mjacob
2735 1.4 mjacob mbs.param[0] = MBOX_GET_DEV_QUEUE_STATUS;
2736 1.25 mjacob mbs.param[1] = (XS_TGT(xs) << 8) | XS_LUN(xs);
2737 1.10 mjacob isp_mboxcmd(isp, &mbs);
2738 1.4 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2739 1.10 mjacob isp_dumpregs(isp, "couldn't GET DEVICE QUEUE STATUS");
2740 1.10 mjacob return;
2741 1.10 mjacob }
2742 1.23 mjacob PRINTF("%s: lost command for target %d lun %d, %d active of %d, "
2743 1.23 mjacob "Queue State: %x\n", isp->isp_name, XS_TGT(xs),
2744 1.23 mjacob XS_LUN(xs), mbs.param[2], mbs.param[3], mbs.param[1]);
2745 1.10 mjacob
2746 1.10 mjacob isp_dumpregs(isp, "lost command");
2747 1.10 mjacob /*
2748 1.10 mjacob * XXX: Need to try and do something to recover.
2749 1.10 mjacob */
2750 1.10 mjacob }
2751 1.10 mjacob
2752 1.10 mjacob static void
2753 1.25 mjacob isp_dumpregs(isp, msg)
2754 1.25 mjacob struct ispsoftc *isp;
2755 1.25 mjacob const char *msg;
2756 1.10 mjacob {
2757 1.23 mjacob PRINTF("%s: %s\n", isp->isp_name, msg);
2758 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI)
2759 1.23 mjacob PRINTF(" biu_conf1=%x", ISP_READ(isp, BIU_CONF1));
2760 1.10 mjacob else
2761 1.23 mjacob PRINTF(" biu_csr=%x", ISP_READ(isp, BIU2100_CSR));
2762 1.23 mjacob PRINTF(" biu_icr=%x biu_isr=%x biu_sema=%x ", ISP_READ(isp, BIU_ICR),
2763 1.10 mjacob ISP_READ(isp, BIU_ISR), ISP_READ(isp, BIU_SEMA));
2764 1.23 mjacob PRINTF("risc_hccr=%x\n", ISP_READ(isp, HCCR));
2765 1.10 mjacob
2766 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
2767 1.10 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
2768 1.23 mjacob PRINTF(" cdma_conf=%x cdma_sts=%x cdma_fifostat=%x\n",
2769 1.10 mjacob ISP_READ(isp, CDMA_CONF), ISP_READ(isp, CDMA_STATUS),
2770 1.10 mjacob ISP_READ(isp, CDMA_FIFO_STS));
2771 1.23 mjacob PRINTF(" ddma_conf=%x ddma_sts=%x ddma_fifostat=%x\n",
2772 1.10 mjacob ISP_READ(isp, DDMA_CONF), ISP_READ(isp, DDMA_STATUS),
2773 1.10 mjacob ISP_READ(isp, DDMA_FIFO_STS));
2774 1.23 mjacob PRINTF(" sxp_int=%x sxp_gross=%x sxp(scsi_ctrl)=%x\n",
2775 1.10 mjacob ISP_READ(isp, SXP_INTERRUPT),
2776 1.10 mjacob ISP_READ(isp, SXP_GROSS_ERR),
2777 1.10 mjacob ISP_READ(isp, SXP_PINS_CONTROL));
2778 1.10 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
2779 1.10 mjacob }
2780 1.10 mjacob ISP_DUMPREGS(isp);
2781 1.10 mjacob }
2782 1.10 mjacob
2783 1.10 mjacob static void
2784 1.25 mjacob isp_dumpxflist(isp)
2785 1.25 mjacob struct ispsoftc *isp;
2786 1.23 mjacob {
2787 1.23 mjacob volatile ISP_SCSI_XFER_T *xs;
2788 1.23 mjacob int i, hdp;
2789 1.23 mjacob
2790 1.23 mjacob for (hdp = i = 0; i < RQUEST_QUEUE_LEN; i++) {
2791 1.23 mjacob xs = isp->isp_xflist[i];
2792 1.23 mjacob if (xs == NULL) {
2793 1.23 mjacob continue;
2794 1.23 mjacob }
2795 1.23 mjacob if (hdp == 0) {
2796 1.23 mjacob PRINTF("%s: active requests\n", isp->isp_name);
2797 1.23 mjacob hdp++;
2798 1.23 mjacob }
2799 1.23 mjacob PRINTF(" Active Handle %d: tgt %d lun %d dlen %d\n",
2800 1.23 mjacob i+1, XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs));
2801 1.23 mjacob }
2802 1.23 mjacob }
2803 1.23 mjacob
2804 1.23 mjacob static void
2805 1.25 mjacob isp_fw_state(isp)
2806 1.25 mjacob struct ispsoftc *isp;
2807 1.10 mjacob {
2808 1.10 mjacob mbreg_t mbs;
2809 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
2810 1.10 mjacob int once = 0;
2811 1.10 mjacob fcparam *fcp = isp->isp_param;
2812 1.10 mjacob again:
2813 1.10 mjacob mbs.param[0] = MBOX_GET_FW_STATE;
2814 1.10 mjacob isp_mboxcmd(isp, &mbs);
2815 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2816 1.25 mjacob if (mbs.param[0] == ASYNC_LIP_OCCURRED ||
2817 1.28 mjacob mbs.param[0] == ASYNC_PDB_CHANGED ||
2818 1.25 mjacob mbs.param[0] == ASYNC_LOOP_UP) {
2819 1.25 mjacob if (once++ < 2) {
2820 1.10 mjacob goto again;
2821 1.10 mjacob }
2822 1.10 mjacob }
2823 1.10 mjacob isp_dumpregs(isp, "GET FIRMWARE STATE failed");
2824 1.10 mjacob return;
2825 1.10 mjacob }
2826 1.10 mjacob fcp->isp_fwstate = mbs.param[1];
2827 1.10 mjacob }
2828 1.10 mjacob }
2829 1.10 mjacob
2830 1.10 mjacob static void
2831 1.25 mjacob isp_update(isp)
2832 1.25 mjacob struct ispsoftc *isp;
2833 1.10 mjacob {
2834 1.25 mjacob int tgt;
2835 1.10 mjacob mbreg_t mbs;
2836 1.10 mjacob sdparam *sdp;
2837 1.10 mjacob
2838 1.25 mjacob isp->isp_update = 0;
2839 1.25 mjacob
2840 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
2841 1.4 mjacob return;
2842 1.4 mjacob }
2843 1.10 mjacob
2844 1.25 mjacob sdp = isp->isp_param;
2845 1.25 mjacob for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
2846 1.25 mjacob if (sdp->isp_devparam[tgt].dev_enable == 0) {
2847 1.25 mjacob continue;
2848 1.25 mjacob }
2849 1.25 mjacob if (sdp->isp_devparam[tgt].dev_update == 0) {
2850 1.25 mjacob continue;
2851 1.25 mjacob }
2852 1.25 mjacob
2853 1.25 mjacob mbs.param[0] = MBOX_SET_TARGET_PARAMS;
2854 1.25 mjacob mbs.param[1] = tgt << 8;
2855 1.25 mjacob mbs.param[2] = sdp->isp_devparam[tgt].dev_flags;
2856 1.25 mjacob mbs.param[3] =
2857 1.25 mjacob (sdp->isp_devparam[tgt].sync_offset << 8) |
2858 1.25 mjacob (sdp->isp_devparam[tgt].sync_period);
2859 1.25 mjacob
2860 1.25 mjacob IDPRINTF(3, ("\n%s: tgt %d cflags %x offset %x period %x\n",
2861 1.25 mjacob isp->isp_name, tgt, mbs.param[2], mbs.param[3] >> 8,
2862 1.25 mjacob mbs.param[3] & 0xff));
2863 1.25 mjacob
2864 1.25 mjacob isp_mboxcmd(isp, &mbs);
2865 1.25 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2866 1.25 mjacob PRINTF("%s: failed to change SCSI parameters for "
2867 1.25 mjacob "target %d\n", isp->isp_name, tgt);
2868 1.25 mjacob } else {
2869 1.25 mjacob char *wt;
2870 1.25 mjacob int x, flags;
2871 1.25 mjacob
2872 1.25 mjacob flags = sdp->isp_devparam[tgt].cur_dflags =
2873 1.25 mjacob sdp->isp_devparam[tgt].dev_flags;
2874 1.25 mjacob
2875 1.25 mjacob x = sdp->isp_devparam[tgt].sync_period & 0xff;
2876 1.25 mjacob if (flags & DPARM_SYNC) {
2877 1.25 mjacob if (x == (ISP_20M_SYNCPARMS & 0xff)) {
2878 1.25 mjacob x = 20;
2879 1.25 mjacob } else if (x == (ISP_10M_SYNCPARMS & 0xff)) {
2880 1.25 mjacob x = 10;
2881 1.25 mjacob } else if (x == (ISP_08M_SYNCPARMS & 0xff)) {
2882 1.25 mjacob x = 8;
2883 1.25 mjacob } else if (x == (ISP_05M_SYNCPARMS & 0xff)) {
2884 1.25 mjacob x = 5;
2885 1.25 mjacob } else if (x == (ISP_04M_SYNCPARMS & 0xff)) {
2886 1.25 mjacob x = 4;
2887 1.25 mjacob } else {
2888 1.25 mjacob x = 0;
2889 1.25 mjacob }
2890 1.25 mjacob } else {
2891 1.25 mjacob x = 0;
2892 1.25 mjacob }
2893 1.25 mjacob switch (flags & (DPARM_WIDE|DPARM_TQING)) {
2894 1.25 mjacob case DPARM_WIDE:
2895 1.25 mjacob wt = ", 16 bit wide\n";
2896 1.25 mjacob break;
2897 1.25 mjacob case DPARM_TQING:
2898 1.25 mjacob wt = ", Tagged Queueing Enabled\n";
2899 1.25 mjacob break;
2900 1.25 mjacob case DPARM_WIDE|DPARM_TQING:
2901 1.25 mjacob wt = ", 16 bit wide, Tagged Queueing Enabled\n";
2902 1.25 mjacob break;
2903 1.25 mjacob
2904 1.25 mjacob default:
2905 1.25 mjacob wt = "\n";
2906 1.25 mjacob break;
2907 1.25 mjacob }
2908 1.25 mjacob if (x) {
2909 1.26 mjacob IDPRINTF(3, ("%s: Target %d maximum Sync Mode "
2910 1.25 mjacob "at %dMHz%s", isp->isp_name, tgt, x, wt));
2911 1.25 mjacob } else {
2912 1.26 mjacob IDPRINTF(3, ("%s: Target %d Async Mode%s",
2913 1.25 mjacob isp->isp_name, tgt, wt));
2914 1.25 mjacob }
2915 1.25 mjacob }
2916 1.25 mjacob sdp->isp_devparam[tgt].dev_update = 0;
2917 1.10 mjacob }
2918 1.25 mjacob }
2919 1.10 mjacob
2920 1.25 mjacob static void
2921 1.25 mjacob isp_setdfltparm(isp)
2922 1.25 mjacob struct ispsoftc *isp;
2923 1.25 mjacob {
2924 1.25 mjacob int i, use_nvram;
2925 1.25 mjacob mbreg_t mbs;
2926 1.25 mjacob sdparam *sdp;
2927 1.10 mjacob
2928 1.10 mjacob /*
2929 1.25 mjacob * Been there, done that, got the T-shirt...
2930 1.10 mjacob */
2931 1.25 mjacob if (isp->isp_gotdparms) {
2932 1.25 mjacob IDPRINTF(3, ("%s: already have dparms\n", isp->isp_name));
2933 1.25 mjacob return;
2934 1.25 mjacob }
2935 1.25 mjacob isp->isp_gotdparms = 1;
2936 1.25 mjacob
2937 1.25 mjacob use_nvram = (isp_read_nvram(isp) == 0);
2938 1.25 mjacob if (use_nvram) {
2939 1.25 mjacob return;
2940 1.25 mjacob }
2941 1.25 mjacob if (isp->isp_type & ISP_HA_FC) {
2942 1.25 mjacob fcparam *fcp = (fcparam *) isp->isp_param;
2943 1.25 mjacob fcp->isp_maxfrmlen = ICB_DFLT_FRMLEN;
2944 1.25 mjacob fcp->isp_maxalloc = 256;
2945 1.25 mjacob fcp->isp_execthrottle = 16;
2946 1.25 mjacob fcp->isp_retry_delay = 5;
2947 1.25 mjacob fcp->isp_retry_count = 0;
2948 1.25 mjacob /*
2949 1.25 mjacob * It would be nice to fake up a WWN in case we don't
2950 1.25 mjacob * get one out of NVRAM. Solaris does this for SOCAL
2951 1.25 mjacob * cards that don't have SBus properties- it sets up
2952 1.25 mjacob * a WWN based upon the system MAC Address.
2953 1.25 mjacob */
2954 1.25 mjacob fcp->isp_wwn = 0;
2955 1.25 mjacob return;
2956 1.10 mjacob }
2957 1.10 mjacob
2958 1.25 mjacob sdp = (sdparam *) isp->isp_param;
2959 1.10 mjacob mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
2960 1.10 mjacob isp_mboxcmd(isp, &mbs);
2961 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2962 1.23 mjacob IDPRINTF(2, ("could not GET ACT NEG STATE\n"));
2963 1.10 mjacob sdp->isp_req_ack_active_neg = 1;
2964 1.10 mjacob sdp->isp_data_line_active_neg = 1;
2965 1.10 mjacob } else {
2966 1.10 mjacob sdp->isp_req_ack_active_neg = (mbs.param[1] >> 4) & 0x1;
2967 1.10 mjacob sdp->isp_data_line_active_neg = (mbs.param[1] >> 5) & 0x1;
2968 1.10 mjacob }
2969 1.10 mjacob for (i = 0; i < MAX_TARGETS; i++) {
2970 1.25 mjacob
2971 1.10 mjacob mbs.param[0] = MBOX_GET_TARGET_PARAMS;
2972 1.10 mjacob mbs.param[1] = i << 8;
2973 1.10 mjacob isp_mboxcmd(isp, &mbs);
2974 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2975 1.25 mjacob PRINTF("%s: can't get SCSI parameters for target %d\n",
2976 1.25 mjacob isp->isp_name, i);
2977 1.25 mjacob sdp->isp_devparam[i].sync_period = 0;
2978 1.25 mjacob sdp->isp_devparam[i].sync_offset = 0;
2979 1.25 mjacob sdp->isp_devparam[i].dev_flags = DPARM_SAFE_DFLT;
2980 1.25 mjacob continue;
2981 1.25 mjacob }
2982 1.25 mjacob sdp->isp_devparam[i].dev_flags = mbs.param[2];
2983 1.25 mjacob
2984 1.25 mjacob /*
2985 1.25 mjacob * The maximum period we can really see
2986 1.25 mjacob * here is 100 (decimal), or 400 ns.
2987 1.25 mjacob * For some unknown reason we sometimes
2988 1.25 mjacob * get back wildass numbers from the
2989 1.25 mjacob * boot device's parameters.
2990 1.25 mjacob *
2991 1.25 mjacob * XXX: Hmm- this may be based on a different
2992 1.25 mjacob * XXX: clock rate.
2993 1.25 mjacob */
2994 1.25 mjacob if ((mbs.param[3] & 0xff) <= 0x64) {
2995 1.25 mjacob sdp->isp_devparam[i].sync_period = mbs.param[3] & 0xff;
2996 1.25 mjacob sdp->isp_devparam[i].sync_offset = mbs.param[3] >> 8;
2997 1.25 mjacob }
2998 1.25 mjacob
2999 1.25 mjacob /*
3000 1.25 mjacob * It is not safe to run Ultra Mode with a clock < 60.
3001 1.25 mjacob */
3002 1.25 mjacob if (((sdp->isp_clock && sdp->isp_clock < 60) ||
3003 1.25 mjacob (isp->isp_type < ISP_HA_SCSI_1020A)) &&
3004 1.25 mjacob (sdp->isp_devparam[i].sync_period ==
3005 1.25 mjacob (ISP_20M_SYNCPARMS & 0xff))) {
3006 1.25 mjacob sdp->isp_devparam[i].sync_offset =
3007 1.25 mjacob ISP_10M_SYNCPARMS >> 8;
3008 1.10 mjacob sdp->isp_devparam[i].sync_period =
3009 1.10 mjacob ISP_10M_SYNCPARMS & 0xff;
3010 1.10 mjacob }
3011 1.25 mjacob
3012 1.10 mjacob }
3013 1.10 mjacob
3014 1.10 mjacob /*
3015 1.10 mjacob * Set Default Host Adapter Parameters
3016 1.10 mjacob */
3017 1.10 mjacob sdp->isp_cmd_dma_burst_enable = 1;
3018 1.10 mjacob sdp->isp_data_dma_burst_enabl = 1;
3019 1.25 mjacob sdp->isp_fifo_threshold = 0;
3020 1.10 mjacob sdp->isp_initiator_id = 7;
3021 1.25 mjacob if (isp->isp_type >= ISP_HA_SCSI_1040) {
3022 1.25 mjacob sdp->isp_async_data_setup = 9;
3023 1.25 mjacob } else {
3024 1.25 mjacob sdp->isp_async_data_setup = 6;
3025 1.25 mjacob }
3026 1.10 mjacob sdp->isp_selection_timeout = 250;
3027 1.23 mjacob sdp->isp_max_queue_depth = 128;
3028 1.10 mjacob sdp->isp_tag_aging = 8;
3029 1.10 mjacob sdp->isp_bus_reset_delay = 3;
3030 1.10 mjacob sdp->isp_retry_count = 0;
3031 1.10 mjacob sdp->isp_retry_delay = 1;
3032 1.10 mjacob
3033 1.10 mjacob for (i = 0; i < MAX_TARGETS; i++) {
3034 1.10 mjacob sdp->isp_devparam[i].exc_throttle = 16;
3035 1.10 mjacob sdp->isp_devparam[i].dev_enable = 1;
3036 1.10 mjacob }
3037 1.10 mjacob }
3038 1.10 mjacob
3039 1.24 mjacob /*
3040 1.24 mjacob * Re-initialize the ISP and complete all orphaned commands
3041 1.24 mjacob * with a 'botched' notice.
3042 1.24 mjacob *
3043 1.24 mjacob * Locks held prior to coming here.
3044 1.24 mjacob */
3045 1.24 mjacob
3046 1.24 mjacob void
3047 1.25 mjacob isp_restart(isp)
3048 1.25 mjacob struct ispsoftc *isp;
3049 1.10 mjacob {
3050 1.23 mjacob ISP_SCSI_XFER_T *tlist[RQUEST_QUEUE_LEN], *xs;
3051 1.10 mjacob int i;
3052 1.10 mjacob
3053 1.23 mjacob for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
3054 1.23 mjacob tlist[i] = (ISP_SCSI_XFER_T *) isp->isp_xflist[i];
3055 1.27 mjacob isp->isp_xflist[i] = NULL;
3056 1.10 mjacob }
3057 1.10 mjacob isp_reset(isp);
3058 1.24 mjacob if (isp->isp_state == ISP_RESETSTATE) {
3059 1.24 mjacob isp_init(isp);
3060 1.24 mjacob if (isp->isp_state == ISP_INITSTATE) {
3061 1.24 mjacob isp->isp_state = ISP_RUNSTATE;
3062 1.24 mjacob }
3063 1.24 mjacob }
3064 1.24 mjacob if (isp->isp_state != ISP_RUNSTATE) {
3065 1.24 mjacob PRINTF("%s: isp_restart cannot restart ISP\n", isp->isp_name);
3066 1.24 mjacob }
3067 1.10 mjacob
3068 1.23 mjacob for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
3069 1.10 mjacob xs = tlist[i];
3070 1.27 mjacob if (XS_NULL(xs)) {
3071 1.10 mjacob continue;
3072 1.27 mjacob }
3073 1.28 mjacob if (isp->isp_nactive > 0)
3074 1.28 mjacob isp->isp_nactive--;
3075 1.23 mjacob XS_RESID(xs) = XS_XFRLEN(xs);
3076 1.27 mjacob XS_SETERR(xs, HBA_BUSRESET);
3077 1.23 mjacob XS_CMD_DONE(xs);
3078 1.10 mjacob }
3079 1.15 mjacob }
3080 1.15 mjacob
3081 1.28 mjacob /*
3082 1.28 mjacob * Miscellaneous debug statements.
3083 1.28 mjacob */
3084 1.15 mjacob static void
3085 1.25 mjacob isp_prtstst(sp)
3086 1.25 mjacob ispstatusreq_t *sp;
3087 1.15 mjacob {
3088 1.23 mjacob PRINTF("states->");
3089 1.15 mjacob if (sp->req_state_flags & RQSF_GOT_BUS)
3090 1.23 mjacob PRINTF("GOT_BUS ");
3091 1.15 mjacob if (sp->req_state_flags & RQSF_GOT_TARGET)
3092 1.23 mjacob PRINTF("GOT_TGT ");
3093 1.15 mjacob if (sp->req_state_flags & RQSF_SENT_CDB)
3094 1.23 mjacob PRINTF("SENT_CDB ");
3095 1.15 mjacob if (sp->req_state_flags & RQSF_XFRD_DATA)
3096 1.23 mjacob PRINTF("XFRD_DATA ");
3097 1.15 mjacob if (sp->req_state_flags & RQSF_GOT_STATUS)
3098 1.23 mjacob PRINTF("GOT_STS ");
3099 1.15 mjacob if (sp->req_state_flags & RQSF_GOT_SENSE)
3100 1.23 mjacob PRINTF("GOT_SNS ");
3101 1.15 mjacob if (sp->req_state_flags & RQSF_XFER_COMPLETE)
3102 1.23 mjacob PRINTF("XFR_CMPLT ");
3103 1.23 mjacob PRINTF("\n");
3104 1.23 mjacob PRINTF("status->");
3105 1.15 mjacob if (sp->req_status_flags & RQSTF_DISCONNECT)
3106 1.23 mjacob PRINTF("Disconnect ");
3107 1.15 mjacob if (sp->req_status_flags & RQSTF_SYNCHRONOUS)
3108 1.23 mjacob PRINTF("Sync_xfr ");
3109 1.15 mjacob if (sp->req_status_flags & RQSTF_PARITY_ERROR)
3110 1.23 mjacob PRINTF("Parity ");
3111 1.15 mjacob if (sp->req_status_flags & RQSTF_BUS_RESET)
3112 1.23 mjacob PRINTF("Bus_Reset ");
3113 1.15 mjacob if (sp->req_status_flags & RQSTF_DEVICE_RESET)
3114 1.23 mjacob PRINTF("Device_Reset ");
3115 1.15 mjacob if (sp->req_status_flags & RQSTF_ABORTED)
3116 1.23 mjacob PRINTF("Aborted ");
3117 1.15 mjacob if (sp->req_status_flags & RQSTF_TIMEOUT)
3118 1.23 mjacob PRINTF("Timeout ");
3119 1.15 mjacob if (sp->req_status_flags & RQSTF_NEGOTIATION)
3120 1.23 mjacob PRINTF("Negotiation ");
3121 1.23 mjacob PRINTF("\n");
3122 1.25 mjacob }
3123 1.25 mjacob
3124 1.28 mjacob static char *
3125 1.28 mjacob isp2100_fw_statename(state)
3126 1.28 mjacob int state;
3127 1.28 mjacob {
3128 1.28 mjacob switch(state) {
3129 1.28 mjacob case FW_CONFIG_WAIT: return "Config Wait";
3130 1.28 mjacob case FW_WAIT_AL_PA: return "Waiting for AL/PA";
3131 1.28 mjacob case FW_WAIT_LOGIN: return "Wait Login";
3132 1.28 mjacob case FW_READY: return "Ready";
3133 1.28 mjacob case FW_LOSS_OF_SYNC: return "Loss Of Sync";
3134 1.28 mjacob case FW_ERROR: return "Error";
3135 1.28 mjacob case FW_REINIT: return "Re-Init";
3136 1.28 mjacob case FW_NON_PART: return "Nonparticipating";
3137 1.28 mjacob default: return "eh?";
3138 1.28 mjacob }
3139 1.28 mjacob }
3140 1.28 mjacob
3141 1.25 mjacob /*
3142 1.25 mjacob * NVRAM Routines
3143 1.25 mjacob */
3144 1.25 mjacob
3145 1.25 mjacob static int
3146 1.25 mjacob isp_read_nvram(isp)
3147 1.25 mjacob struct ispsoftc *isp;
3148 1.25 mjacob {
3149 1.25 mjacob int i, amt;
3150 1.25 mjacob u_int8_t csum, minversion;
3151 1.25 mjacob union {
3152 1.25 mjacob u_int8_t _x[ISP2100_NVRAM_SIZE];
3153 1.25 mjacob u_int16_t _s[ISP2100_NVRAM_SIZE>>1];
3154 1.25 mjacob } _n;
3155 1.25 mjacob #define nvram_data _n._x
3156 1.25 mjacob #define nvram_words _n._s
3157 1.25 mjacob
3158 1.25 mjacob if (isp->isp_type & ISP_HA_FC) {
3159 1.25 mjacob amt = ISP2100_NVRAM_SIZE;
3160 1.25 mjacob minversion = 1;
3161 1.25 mjacob } else {
3162 1.25 mjacob amt = ISP_NVRAM_SIZE;
3163 1.25 mjacob minversion = 2;
3164 1.25 mjacob }
3165 1.25 mjacob
3166 1.25 mjacob /*
3167 1.25 mjacob * Just read the first two words first to see if we have a valid
3168 1.25 mjacob * NVRAM to continue reading the rest with.
3169 1.25 mjacob */
3170 1.25 mjacob for (i = 0; i < 2; i++) {
3171 1.25 mjacob isp_rdnvram_word(isp, i, &nvram_words[i]);
3172 1.25 mjacob }
3173 1.25 mjacob if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
3174 1.25 mjacob nvram_data[2] != 'P') {
3175 1.25 mjacob if (isp->isp_bustype != ISP_BT_SBUS) {
3176 1.25 mjacob PRINTF("%s: invalid NVRAM header\n", isp->isp_name);
3177 1.25 mjacob }
3178 1.25 mjacob return (-1);
3179 1.25 mjacob }
3180 1.25 mjacob for (i = 2; i < amt>>1; i++) {
3181 1.25 mjacob isp_rdnvram_word(isp, i, &nvram_words[i]);
3182 1.25 mjacob }
3183 1.25 mjacob for (csum = 0, i = 0; i < amt; i++) {
3184 1.25 mjacob csum += nvram_data[i];
3185 1.25 mjacob }
3186 1.25 mjacob if (csum != 0) {
3187 1.25 mjacob PRINTF("%s: invalid NVRAM checksum\n", isp->isp_name);
3188 1.25 mjacob return (-1);
3189 1.25 mjacob }
3190 1.25 mjacob if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
3191 1.25 mjacob PRINTF("%s: version %d NVRAM not understood\n", isp->isp_name,
3192 1.25 mjacob ISP_NVRAM_VERSION(nvram_data));
3193 1.25 mjacob return (-1);
3194 1.25 mjacob }
3195 1.25 mjacob
3196 1.25 mjacob if (isp->isp_type & ISP_HA_SCSI) {
3197 1.25 mjacob sdparam *sdp = (sdparam *) isp->isp_param;
3198 1.25 mjacob
3199 1.25 mjacob /* XXX CHECK THIS FOR SANITY XXX */
3200 1.25 mjacob sdp->isp_fifo_threshold =
3201 1.25 mjacob ISP_NVRAM_FIFO_THRESHOLD(nvram_data);
3202 1.25 mjacob
3203 1.25 mjacob sdp->isp_initiator_id =
3204 1.25 mjacob ISP_NVRAM_INITIATOR_ID(nvram_data);
3205 1.25 mjacob
3206 1.25 mjacob sdp->isp_bus_reset_delay =
3207 1.25 mjacob ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
3208 1.25 mjacob
3209 1.25 mjacob sdp->isp_retry_count =
3210 1.25 mjacob ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
3211 1.25 mjacob
3212 1.25 mjacob sdp->isp_retry_delay =
3213 1.25 mjacob ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
3214 1.25 mjacob
3215 1.25 mjacob sdp->isp_async_data_setup =
3216 1.25 mjacob ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
3217 1.25 mjacob
3218 1.25 mjacob if (isp->isp_type >= ISP_HA_SCSI_1040) {
3219 1.25 mjacob if (sdp->isp_async_data_setup < 9) {
3220 1.25 mjacob sdp->isp_async_data_setup = 9;
3221 1.25 mjacob }
3222 1.25 mjacob } else {
3223 1.25 mjacob if (sdp->isp_async_data_setup != 6) {
3224 1.25 mjacob sdp->isp_async_data_setup = 6;
3225 1.25 mjacob }
3226 1.25 mjacob }
3227 1.25 mjacob
3228 1.25 mjacob sdp->isp_req_ack_active_neg =
3229 1.25 mjacob ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
3230 1.25 mjacob
3231 1.25 mjacob sdp->isp_data_line_active_neg =
3232 1.25 mjacob ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
3233 1.25 mjacob
3234 1.25 mjacob sdp->isp_data_dma_burst_enabl =
3235 1.25 mjacob ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
3236 1.25 mjacob
3237 1.25 mjacob sdp->isp_cmd_dma_burst_enable =
3238 1.25 mjacob ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
3239 1.25 mjacob
3240 1.25 mjacob sdp->isp_tag_aging =
3241 1.25 mjacob ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
3242 1.25 mjacob
3243 1.25 mjacob /* XXX ISP_NVRAM_FIFO_THRESHOLD_128 XXX */
3244 1.25 mjacob
3245 1.25 mjacob sdp->isp_selection_timeout =
3246 1.25 mjacob ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
3247 1.25 mjacob
3248 1.25 mjacob sdp->isp_max_queue_depth =
3249 1.25 mjacob ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
3250 1.25 mjacob
3251 1.25 mjacob sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
3252 1.25 mjacob
3253 1.25 mjacob for (i = 0; i < 16; i++) {
3254 1.25 mjacob sdp->isp_devparam[i].dev_enable =
3255 1.25 mjacob ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i);
3256 1.25 mjacob sdp->isp_devparam[i].exc_throttle =
3257 1.25 mjacob ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, i);
3258 1.25 mjacob sdp->isp_devparam[i].sync_offset =
3259 1.25 mjacob ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, i);
3260 1.25 mjacob sdp->isp_devparam[i].sync_period =
3261 1.25 mjacob ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, i);
3262 1.25 mjacob
3263 1.25 mjacob if (isp->isp_type < ISP_HA_SCSI_1040) {
3264 1.25 mjacob /*
3265 1.25 mjacob * If we're not ultra, we can't possibly
3266 1.25 mjacob * be a shorter period than this.
3267 1.25 mjacob */
3268 1.25 mjacob if (sdp->isp_devparam[i].sync_period < 0x19) {
3269 1.25 mjacob sdp->isp_devparam[i].sync_period =
3270 1.25 mjacob 0x19;
3271 1.25 mjacob }
3272 1.25 mjacob if (sdp->isp_devparam[i].sync_offset > 0xc) {
3273 1.25 mjacob sdp->isp_devparam[i].sync_offset =
3274 1.25 mjacob 0x0c;
3275 1.25 mjacob }
3276 1.25 mjacob } else {
3277 1.25 mjacob if (sdp->isp_devparam[i].sync_offset > 0x8) {
3278 1.25 mjacob sdp->isp_devparam[i].sync_offset = 0x8;
3279 1.25 mjacob }
3280 1.25 mjacob }
3281 1.25 mjacob
3282 1.25 mjacob sdp->isp_devparam[i].dev_flags = 0;
3283 1.25 mjacob
3284 1.25 mjacob if (ISP_NVRAM_TGT_RENEG(nvram_data, i))
3285 1.25 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_RENEG;
3286 1.25 mjacob if (ISP_NVRAM_TGT_QFRZ(nvram_data, i)) {
3287 1.25 mjacob PRINTF("%s: not supporting QFRZ option for "
3288 1.25 mjacob "target %d\n", isp->isp_name, i);
3289 1.25 mjacob }
3290 1.25 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_ARQ;
3291 1.25 mjacob if (ISP_NVRAM_TGT_ARQ(nvram_data, i) == 0) {
3292 1.25 mjacob PRINTF("%s: not disabling ARQ option for "
3293 1.25 mjacob "target %d\n", isp->isp_name, i);
3294 1.25 mjacob }
3295 1.25 mjacob if (ISP_NVRAM_TGT_TQING(nvram_data, i))
3296 1.25 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_TQING;
3297 1.25 mjacob if (ISP_NVRAM_TGT_SYNC(nvram_data, i))
3298 1.25 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_SYNC;
3299 1.25 mjacob if (ISP_NVRAM_TGT_WIDE(nvram_data, i))
3300 1.25 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_WIDE;
3301 1.25 mjacob if (ISP_NVRAM_TGT_PARITY(nvram_data, i))
3302 1.25 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_PARITY;
3303 1.25 mjacob if (ISP_NVRAM_TGT_DISC(nvram_data, i))
3304 1.25 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_DISC;
3305 1.25 mjacob }
3306 1.25 mjacob } else {
3307 1.25 mjacob fcparam *fcp = (fcparam *) isp->isp_param;
3308 1.25 mjacob union {
3309 1.25 mjacob struct {
3310 1.25 mjacob #if BYTE_ORDER == BIG_ENDIAN
3311 1.25 mjacob u_int32_t hi32;
3312 1.25 mjacob u_int32_t lo32;
3313 1.25 mjacob #else
3314 1.25 mjacob u_int32_t lo32;
3315 1.25 mjacob u_int32_t hi32;
3316 1.25 mjacob #endif
3317 1.25 mjacob } wds;
3318 1.25 mjacob u_int64_t full64;
3319 1.25 mjacob } wwnstore;
3320 1.25 mjacob
3321 1.25 mjacob wwnstore.full64 = ISP2100_NVRAM_NODE_NAME(nvram_data);
3322 1.25 mjacob PRINTF("%s: Adapter WWN 0x%08x%08x\n", isp->isp_name,
3323 1.25 mjacob wwnstore.wds.hi32, wwnstore.wds.lo32);
3324 1.25 mjacob fcp->isp_wwn = wwnstore.full64;
3325 1.25 mjacob wwnstore.full64 = ISP2100_NVRAM_BOOT_NODE_NAME(nvram_data);
3326 1.25 mjacob if (wwnstore.full64 != 0) {
3327 1.28 mjacob PRINTF("%s: BOOT DEVICE WWN 0x%08x%08x\n",
3328 1.28 mjacob isp->isp_name, wwnstore.wds.hi32,
3329 1.28 mjacob wwnstore.wds.lo32);
3330 1.25 mjacob }
3331 1.25 mjacob fcp->isp_maxalloc =
3332 1.25 mjacob ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
3333 1.25 mjacob fcp->isp_maxfrmlen =
3334 1.25 mjacob ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
3335 1.25 mjacob fcp->isp_retry_delay =
3336 1.25 mjacob ISP2100_NVRAM_RETRY_DELAY(nvram_data);
3337 1.25 mjacob fcp->isp_retry_count =
3338 1.25 mjacob ISP2100_NVRAM_RETRY_COUNT(nvram_data);
3339 1.25 mjacob fcp->isp_loopid =
3340 1.25 mjacob ISP2100_NVRAM_HARDLOOPID(nvram_data);
3341 1.25 mjacob fcp->isp_execthrottle =
3342 1.25 mjacob ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
3343 1.25 mjacob }
3344 1.25 mjacob return (0);
3345 1.25 mjacob }
3346 1.25 mjacob
3347 1.25 mjacob static void
3348 1.25 mjacob isp_rdnvram_word(isp, wo, rp)
3349 1.25 mjacob struct ispsoftc *isp;
3350 1.25 mjacob int wo;
3351 1.25 mjacob u_int16_t *rp;
3352 1.25 mjacob {
3353 1.25 mjacob int i, cbits;
3354 1.25 mjacob u_int16_t bit, rqst;
3355 1.25 mjacob
3356 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
3357 1.25 mjacob SYS_DELAY(2);
3358 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
3359 1.25 mjacob SYS_DELAY(2);
3360 1.25 mjacob
3361 1.25 mjacob if (isp->isp_type & ISP_HA_FC) {
3362 1.25 mjacob wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
3363 1.25 mjacob rqst = (ISP_NVRAM_READ << 8) | wo;
3364 1.25 mjacob cbits = 10;
3365 1.25 mjacob } else {
3366 1.25 mjacob wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
3367 1.25 mjacob rqst = (ISP_NVRAM_READ << 6) | wo;
3368 1.25 mjacob cbits = 8;
3369 1.25 mjacob }
3370 1.25 mjacob
3371 1.25 mjacob /*
3372 1.25 mjacob * Clock the word select request out...
3373 1.25 mjacob */
3374 1.25 mjacob for (i = cbits; i >= 0; i--) {
3375 1.25 mjacob if ((rqst >> i) & 1) {
3376 1.25 mjacob bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
3377 1.25 mjacob } else {
3378 1.25 mjacob bit = BIU_NVRAM_SELECT;
3379 1.25 mjacob }
3380 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, bit);
3381 1.25 mjacob SYS_DELAY(2);
3382 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
3383 1.25 mjacob SYS_DELAY(2);
3384 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, bit);
3385 1.25 mjacob SYS_DELAY(2);
3386 1.25 mjacob }
3387 1.25 mjacob /*
3388 1.25 mjacob * Now read the result back in (bits come back in MSB format).
3389 1.25 mjacob */
3390 1.25 mjacob *rp = 0;
3391 1.25 mjacob for (i = 0; i < 16; i++) {
3392 1.25 mjacob u_int16_t rv;
3393 1.25 mjacob *rp <<= 1;
3394 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
3395 1.25 mjacob SYS_DELAY(2);
3396 1.25 mjacob rv = ISP_READ(isp, BIU_NVRAM);
3397 1.25 mjacob if (rv & BIU_NVRAM_DATAIN) {
3398 1.25 mjacob *rp |= 1;
3399 1.25 mjacob }
3400 1.25 mjacob SYS_DELAY(2);
3401 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
3402 1.25 mjacob SYS_DELAY(2);
3403 1.25 mjacob }
3404 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, 0);
3405 1.25 mjacob SYS_DELAY(2);
3406 1.25 mjacob #if BYTE_ORDER == BIG_ENDIAN
3407 1.25 mjacob *rp = ((*rp >> 8) | ((*rp & 0xff) << 8));
3408 1.25 mjacob #endif
3409 1.1 cgd }
3410