isp.c revision 1.23 1 1.23 mjacob /* $NetBSD: isp.c,v 1.23 1998/07/15 19:50:16 mjacob Exp $ */
2 1.23 mjacob /* $Id: isp.c,v 1.23 1998/07/15 19:50:16 mjacob Exp $ */
3 1.1 cgd /*
4 1.1 cgd * Machine 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.23 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.23 mjacob * Function prototypes.
66 1.23 mjacob */
67 1.23 mjacob static void isp_parse_status
68 1.23 mjacob __P((struct ispsoftc *, ispstatusreq_t *, ISP_SCSI_XFER_T *));
69 1.10 mjacob static void isp_fibre_init __P((struct ispsoftc *));
70 1.10 mjacob static void isp_fw_state __P((struct ispsoftc *));
71 1.10 mjacob static void isp_dumpregs __P((struct ispsoftc *, const char *));
72 1.23 mjacob static void isp_dumpxflist __P((struct ispsoftc *));
73 1.10 mjacob static void isp_setdparm __P((struct ispsoftc *));
74 1.15 mjacob static void isp_prtstst __P((ispstatusreq_t *));
75 1.23 mjacob static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *));
76 1.1 cgd
77 1.1 cgd /*
78 1.1 cgd * Reset Hardware.
79 1.1 cgd */
80 1.1 cgd void
81 1.1 cgd isp_reset(isp)
82 1.1 cgd struct ispsoftc *isp;
83 1.1 cgd {
84 1.1 cgd mbreg_t mbs;
85 1.23 mjacob int loops, i, dodnld = 1;
86 1.10 mjacob char *revname;
87 1.23 mjacob ISP_LOCKVAL_DECL;
88 1.1 cgd
89 1.1 cgd isp->isp_state = ISP_NILSTATE;
90 1.4 mjacob
91 1.4 mjacob /*
92 1.10 mjacob * Basic types have been set in the MD code.
93 1.10 mjacob * See if we can't figure out more here.
94 1.4 mjacob */
95 1.23 mjacob isp->isp_dblev = DFLT_DBLEVEL;
96 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
97 1.10 mjacob revname = "2100";
98 1.10 mjacob } else {
99 1.10 mjacob i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
100 1.10 mjacob switch (i) {
101 1.10 mjacob default:
102 1.23 mjacob PRINTF("%s: unknown ISP type %x- assuming 1020\n",
103 1.23 mjacob isp->isp_name, i);
104 1.14 mjacob isp->isp_type = ISP_HA_SCSI_1020;
105 1.23 mjacob revname = "10X0";
106 1.10 mjacob break;
107 1.10 mjacob case 1:
108 1.10 mjacob revname = "1020";
109 1.10 mjacob isp->isp_type = ISP_HA_SCSI_1020;
110 1.22 mjacob break;
111 1.22 mjacob case 2:
112 1.22 mjacob revname = "1020A";
113 1.22 mjacob isp->isp_type = ISP_HA_SCSI_1020A;
114 1.10 mjacob break;
115 1.10 mjacob case 3:
116 1.10 mjacob revname = "1040A";
117 1.10 mjacob isp->isp_type = ISP_HA_SCSI_1040A;
118 1.10 mjacob break;
119 1.10 mjacob case 5:
120 1.10 mjacob revname = "1040B";
121 1.10 mjacob isp->isp_type = ISP_HA_SCSI_1040B;
122 1.10 mjacob break;
123 1.8 mjacob }
124 1.4 mjacob }
125 1.8 mjacob
126 1.1 cgd /*
127 1.10 mjacob * Do MD specific pre initialization
128 1.1 cgd */
129 1.23 mjacob ISP_LOCK(isp);
130 1.10 mjacob ISP_RESET0(isp);
131 1.23 mjacob isp_setdparm(isp); /*
132 1.23 mjacob * XXX- need to get rid of thie call
133 1.23 mjacob * XXX- prior to a reset. We need
134 1.23 mjacob * XXX- to get this now only to try
135 1.23 mjacob * XXX- and read the clock settings.
136 1.23 mjacob * XXX- typically for SBus only.
137 1.23 mjacob */
138 1.1 cgd /*
139 1.10 mjacob * Hit the chip over the head with hammer,
140 1.10 mjacob * and give the ISP a chance to recover.
141 1.1 cgd */
142 1.1 cgd
143 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
144 1.10 mjacob ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
145 1.10 mjacob /*
146 1.10 mjacob * A slight delay...
147 1.10 mjacob */
148 1.23 mjacob SYS_DELAY(100);
149 1.10 mjacob
150 1.10 mjacob /*
151 1.10 mjacob * Clear data && control DMA engines.
152 1.10 mjacob */
153 1.10 mjacob ISP_WRITE(isp, CDMA_CONTROL,
154 1.1 cgd DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
155 1.10 mjacob ISP_WRITE(isp, DDMA_CONTROL,
156 1.1 cgd DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
157 1.10 mjacob } else {
158 1.10 mjacob ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
159 1.10 mjacob /*
160 1.10 mjacob * A slight delay...
161 1.10 mjacob */
162 1.23 mjacob SYS_DELAY(100);
163 1.10 mjacob ISP_WRITE(isp, CDMA2100_CONTROL,
164 1.10 mjacob DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
165 1.10 mjacob ISP_WRITE(isp, TDMA2100_CONTROL,
166 1.10 mjacob DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
167 1.10 mjacob ISP_WRITE(isp, RDMA2100_CONTROL,
168 1.10 mjacob DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
169 1.10 mjacob }
170 1.10 mjacob
171 1.1 cgd /*
172 1.1 cgd * Wait for ISP to be ready to go...
173 1.1 cgd */
174 1.1 cgd loops = MBOX_DELAY_COUNT;
175 1.10 mjacob for (;;) {
176 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
177 1.10 mjacob if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET))
178 1.10 mjacob break;
179 1.10 mjacob } else {
180 1.10 mjacob if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
181 1.10 mjacob break;
182 1.10 mjacob }
183 1.23 mjacob SYS_DELAY(100);
184 1.1 cgd if (--loops < 0) {
185 1.10 mjacob isp_dumpregs(isp, "chip reset timed out");
186 1.23 mjacob ISP_UNLOCK(isp);
187 1.1 cgd return;
188 1.1 cgd }
189 1.1 cgd }
190 1.1 cgd /*
191 1.1 cgd * More initialization
192 1.1 cgd */
193 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
194 1.10 mjacob ISP_WRITE(isp, BIU_CONF1, 0);
195 1.10 mjacob } else {
196 1.10 mjacob ISP_WRITE(isp, BIU2100_CSR, 0);
197 1.10 mjacob ISP_WRITE(isp, RISC_MTR2100, 0x1212); /* FM */
198 1.10 mjacob }
199 1.1 cgd
200 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
201 1.23 mjacob SYS_DELAY(100);
202 1.1 cgd
203 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
204 1.1 cgd ISP_SETBITS(isp, BIU_CONF1, isp->isp_mdvec->dv_conf1);
205 1.1 cgd if (isp->isp_mdvec->dv_conf1 & BIU_BURST_ENABLE) {
206 1.1 cgd ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
207 1.1 cgd ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
208 1.1 cgd }
209 1.1 cgd }
210 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
211 1.1 cgd
212 1.1 cgd /*
213 1.1 cgd * Do MD specific post initialization
214 1.1 cgd */
215 1.1 cgd ISP_RESET1(isp);
216 1.1 cgd
217 1.1 cgd /*
218 1.1 cgd * Enable interrupts
219 1.1 cgd */
220 1.10 mjacob ENABLE_INTS(isp);
221 1.1 cgd
222 1.1 cgd /*
223 1.1 cgd * Do some sanity checking.
224 1.1 cgd */
225 1.1 cgd mbs.param[0] = MBOX_NO_OP;
226 1.10 mjacob isp_mboxcmd(isp, &mbs);
227 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
228 1.10 mjacob isp_dumpregs(isp, "NOP test failed");
229 1.23 mjacob ISP_UNLOCK(isp);
230 1.1 cgd return;
231 1.1 cgd }
232 1.1 cgd
233 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
234 1.10 mjacob mbs.param[0] = MBOX_MAILBOX_REG_TEST;
235 1.10 mjacob mbs.param[1] = 0xdead;
236 1.10 mjacob mbs.param[2] = 0xbeef;
237 1.10 mjacob mbs.param[3] = 0xffff;
238 1.10 mjacob mbs.param[4] = 0x1111;
239 1.10 mjacob mbs.param[5] = 0xa5a5;
240 1.10 mjacob isp_mboxcmd(isp, &mbs);
241 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
242 1.10 mjacob isp_dumpregs(isp,
243 1.10 mjacob "Mailbox Register test didn't complete");
244 1.23 mjacob ISP_UNLOCK(isp);
245 1.10 mjacob return;
246 1.10 mjacob }
247 1.10 mjacob if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
248 1.10 mjacob mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
249 1.10 mjacob mbs.param[5] != 0xa5a5) {
250 1.10 mjacob isp_dumpregs(isp, "Register Test Failed");
251 1.23 mjacob ISP_UNLOCK(isp);
252 1.1 cgd return;
253 1.1 cgd }
254 1.10 mjacob
255 1.1 cgd }
256 1.1 cgd
257 1.1 cgd /*
258 1.18 mjacob * Download new Firmware, unless requested not to do so.
259 1.18 mjacob * This is made slightly trickier in some cases where the
260 1.18 mjacob * firmware of the ROM revision is newer than the revision
261 1.18 mjacob * compiled into the driver. So, where we used to compare
262 1.18 mjacob * versions of our f/w and the ROM f/w, now we just see
263 1.18 mjacob * whether we have f/w at all and whether a config flag
264 1.18 mjacob * has disabled our download.
265 1.1 cgd */
266 1.23 mjacob if ((isp->isp_mdvec->dv_fwlen == 0) ||
267 1.23 mjacob (isp->isp_confopts & ISP_CFG_NORELOAD)) {
268 1.10 mjacob dodnld = 0;
269 1.10 mjacob }
270 1.10 mjacob
271 1.10 mjacob if (dodnld) {
272 1.10 mjacob for (i = 0; i < isp->isp_mdvec->dv_fwlen; i++) {
273 1.10 mjacob mbs.param[0] = MBOX_WRITE_RAM_WORD;
274 1.10 mjacob mbs.param[1] = isp->isp_mdvec->dv_codeorg + i;
275 1.10 mjacob mbs.param[2] = isp->isp_mdvec->dv_ispfw[i];
276 1.10 mjacob isp_mboxcmd(isp, &mbs);
277 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
278 1.10 mjacob isp_dumpregs(isp, "f/w download failed");
279 1.23 mjacob ISP_UNLOCK(isp);
280 1.10 mjacob return;
281 1.10 mjacob }
282 1.10 mjacob }
283 1.10 mjacob
284 1.10 mjacob if (isp->isp_mdvec->dv_fwlen) {
285 1.10 mjacob /*
286 1.10 mjacob * Verify that it downloaded correctly.
287 1.10 mjacob */
288 1.10 mjacob mbs.param[0] = MBOX_VERIFY_CHECKSUM;
289 1.10 mjacob mbs.param[1] = isp->isp_mdvec->dv_codeorg;
290 1.10 mjacob isp_mboxcmd(isp, &mbs);
291 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
292 1.10 mjacob isp_dumpregs(isp, "ram checksum failure");
293 1.23 mjacob ISP_UNLOCK(isp);
294 1.10 mjacob return;
295 1.10 mjacob }
296 1.10 mjacob }
297 1.10 mjacob } else {
298 1.20 mjacob IDPRINTF(3, ("%s: skipping f/w download\n", isp->isp_name));
299 1.1 cgd }
300 1.1 cgd
301 1.1 cgd /*
302 1.10 mjacob * Now start it rolling.
303 1.10 mjacob *
304 1.10 mjacob * If we didn't actually download f/w,
305 1.10 mjacob * we still need to (re)start it.
306 1.1 cgd */
307 1.1 cgd
308 1.1 cgd mbs.param[0] = MBOX_EXEC_FIRMWARE;
309 1.1 cgd mbs.param[1] = isp->isp_mdvec->dv_codeorg;
310 1.10 mjacob isp_mboxcmd(isp, &mbs);
311 1.4 mjacob
312 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
313 1.10 mjacob /*
314 1.10 mjacob * Set CLOCK RATE
315 1.10 mjacob */
316 1.10 mjacob if (((sdparam *)isp->isp_param)->isp_clock) {
317 1.10 mjacob mbs.param[0] = MBOX_SET_CLOCK_RATE;
318 1.10 mjacob mbs.param[1] = ((sdparam *)isp->isp_param)->isp_clock;
319 1.10 mjacob isp_mboxcmd(isp, &mbs);
320 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
321 1.10 mjacob isp_dumpregs(isp, "failed to set CLOCKRATE");
322 1.23 mjacob ISP_UNLOCK(isp);
323 1.10 mjacob return;
324 1.10 mjacob }
325 1.4 mjacob }
326 1.4 mjacob }
327 1.1 cgd mbs.param[0] = MBOX_ABOUT_FIRMWARE;
328 1.10 mjacob isp_mboxcmd(isp, &mbs);
329 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
330 1.10 mjacob isp_dumpregs(isp, "ABOUT FIRMWARE command failed");
331 1.23 mjacob ISP_UNLOCK(isp);
332 1.1 cgd return;
333 1.1 cgd }
334 1.23 mjacob PRINTF("%s: Board Revision %s, %s F/W Revision %d.%d\n",
335 1.10 mjacob isp->isp_name, revname, dodnld? "loaded" : "ROM",
336 1.1 cgd mbs.param[1], mbs.param[2]);
337 1.10 mjacob isp_fw_state(isp);
338 1.1 cgd isp->isp_state = ISP_RESETSTATE;
339 1.23 mjacob ISP_UNLOCK(isp);
340 1.1 cgd }
341 1.1 cgd
342 1.1 cgd /*
343 1.1 cgd * Initialize Hardware to known state
344 1.1 cgd */
345 1.1 cgd void
346 1.1 cgd isp_init(isp)
347 1.1 cgd struct ispsoftc *isp;
348 1.1 cgd {
349 1.10 mjacob sdparam *sdp;
350 1.1 cgd mbreg_t mbs;
351 1.23 mjacob int i, l;
352 1.23 mjacob ISP_LOCKVAL_DECL;
353 1.1 cgd
354 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
355 1.10 mjacob isp_fibre_init(isp);
356 1.10 mjacob return;
357 1.1 cgd }
358 1.1 cgd
359 1.10 mjacob sdp = isp->isp_param;
360 1.1 cgd
361 1.10 mjacob /*
362 1.10 mjacob * Try and figure out if we're connected to a differential bus.
363 1.10 mjacob * You have to pause the RISC processor to read SXP registers.
364 1.23 mjacob *
365 1.23 mjacob * This, by the way, is likely broken in that it should be
366 1.23 mjacob * getting this info from NVRAM settings too.
367 1.10 mjacob */
368 1.23 mjacob ISP_LOCK(isp);
369 1.10 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
370 1.10 mjacob if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_SENSE) {
371 1.10 mjacob sdp->isp_diffmode = 1;
372 1.23 mjacob PRINTF("%s: Differential Mode\n", isp->isp_name);
373 1.10 mjacob } else {
374 1.10 mjacob /*
375 1.10 mjacob * Force pullups on.
376 1.10 mjacob */
377 1.10 mjacob sdp->isp_req_ack_active_neg = 1;
378 1.10 mjacob sdp->isp_data_line_active_neg = 1;
379 1.10 mjacob sdp->isp_diffmode = 0;
380 1.10 mjacob }
381 1.10 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
382 1.1 cgd
383 1.10 mjacob mbs.param[0] = MBOX_GET_INIT_SCSI_ID;
384 1.10 mjacob isp_mboxcmd(isp, &mbs);
385 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
386 1.23 mjacob ISP_UNLOCK(isp);
387 1.10 mjacob isp_dumpregs(isp, "failed to get initiator id");
388 1.1 cgd return;
389 1.1 cgd }
390 1.10 mjacob if (mbs.param[1] != sdp->isp_initiator_id) {
391 1.23 mjacob PRINTF("%s: setting Initiator ID to %d\n", isp->isp_name,
392 1.10 mjacob sdp->isp_initiator_id);
393 1.10 mjacob mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
394 1.10 mjacob mbs.param[1] = sdp->isp_initiator_id;
395 1.10 mjacob isp_mboxcmd(isp, &mbs);
396 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
397 1.23 mjacob ISP_UNLOCK(isp);
398 1.10 mjacob isp_dumpregs(isp, "failed to set initiator id");
399 1.10 mjacob return;
400 1.10 mjacob }
401 1.10 mjacob } else {
402 1.20 mjacob IDPRINTF(3, ("%s: leaving Initiator ID at %d\n", isp->isp_name,
403 1.10 mjacob sdp->isp_initiator_id));
404 1.10 mjacob }
405 1.1 cgd
406 1.1 cgd mbs.param[0] = MBOX_SET_RETRY_COUNT;
407 1.10 mjacob mbs.param[1] = sdp->isp_retry_count;
408 1.10 mjacob mbs.param[2] = sdp->isp_retry_delay;
409 1.10 mjacob isp_mboxcmd(isp, &mbs);
410 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
411 1.23 mjacob ISP_UNLOCK(isp);
412 1.10 mjacob isp_dumpregs(isp, "failed to set retry count and delay");
413 1.1 cgd return;
414 1.1 cgd }
415 1.1 cgd
416 1.1 cgd mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
417 1.10 mjacob mbs.param[1] = sdp->isp_async_data_setup;
418 1.10 mjacob isp_mboxcmd(isp, &mbs);
419 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
420 1.23 mjacob ISP_UNLOCK(isp);
421 1.10 mjacob isp_dumpregs(isp, "failed to set async data setup time");
422 1.1 cgd return;
423 1.1 cgd }
424 1.1 cgd
425 1.1 cgd mbs.param[0] = MBOX_SET_ACTIVE_NEG_STATE;
426 1.10 mjacob mbs.param[1] = (sdp->isp_req_ack_active_neg << 4) |
427 1.10 mjacob (sdp->isp_data_line_active_neg << 5);
428 1.10 mjacob isp_mboxcmd(isp, &mbs);
429 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
430 1.23 mjacob ISP_UNLOCK(isp);
431 1.10 mjacob isp_dumpregs(isp, "failed to set active neg state");
432 1.1 cgd return;
433 1.1 cgd }
434 1.1 cgd
435 1.1 cgd mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
436 1.10 mjacob mbs.param[1] = sdp->isp_tag_aging;
437 1.10 mjacob isp_mboxcmd(isp, &mbs);
438 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
439 1.23 mjacob ISP_UNLOCK(isp);
440 1.10 mjacob isp_dumpregs(isp, "failed to set tag age limit");
441 1.1 cgd return;
442 1.1 cgd }
443 1.1 cgd
444 1.1 cgd mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
445 1.10 mjacob mbs.param[1] = sdp->isp_selection_timeout;
446 1.10 mjacob isp_mboxcmd(isp, &mbs);
447 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
448 1.23 mjacob ISP_UNLOCK(isp);
449 1.10 mjacob isp_dumpregs(isp, "failed to set selection timeout");
450 1.1 cgd return;
451 1.1 cgd }
452 1.1 cgd
453 1.20 mjacob IDPRINTF(2, ("%s: devparm, W=wide, S=sync, T=Tag\n", isp->isp_name));
454 1.1 cgd for (i = 0; i < MAX_TARGETS; i++) {
455 1.21 mjacob char bz[9];
456 1.23 mjacob u_int16_t cj = sdp->isp_devparam[i].sync_period;
457 1.10 mjacob
458 1.10 mjacob if (sdp->isp_devparam[i].dev_flags & DPARM_SYNC) {
459 1.20 mjacob u_int16_t x;
460 1.23 mjacob if (cj == (ISP_20M_SYNCPARMS & 0xff)) {
461 1.20 mjacob x = 20;
462 1.23 mjacob } else if (cj == (ISP_10M_SYNCPARMS & 0xff)) {
463 1.20 mjacob x = 10;
464 1.23 mjacob } else if (cj == (ISP_08M_SYNCPARMS & 0xff)) {
465 1.20 mjacob x = 8;
466 1.23 mjacob } else if (cj == (ISP_05M_SYNCPARMS & 0xff)) {
467 1.20 mjacob x = 5;
468 1.23 mjacob } else if (cj == (ISP_04M_SYNCPARMS & 0xff)) {
469 1.20 mjacob x = 4;
470 1.10 mjacob } else {
471 1.20 mjacob x = 0;
472 1.10 mjacob }
473 1.23 mjacob if (x)
474 1.23 mjacob sprintf(bz, "%02dMHz:", x);
475 1.23 mjacob else
476 1.23 mjacob sprintf(bz, "?%04x:", cj);
477 1.10 mjacob } else {
478 1.20 mjacob sprintf(bz, "Async:");
479 1.10 mjacob }
480 1.10 mjacob if (sdp->isp_devparam[i].dev_flags & DPARM_WIDE)
481 1.21 mjacob bz[6] = 'W';
482 1.10 mjacob else
483 1.21 mjacob bz[6] = ' ';
484 1.10 mjacob if (sdp->isp_devparam[i].dev_flags & DPARM_TQING)
485 1.21 mjacob bz[7] = 'T';
486 1.10 mjacob else
487 1.21 mjacob bz[7] = ' ';
488 1.21 mjacob bz[8] = 0;
489 1.21 mjacob IDPRINTF(2, (" id%x:%s", i, bz));
490 1.10 mjacob if (((i+1) & 0x3) == 0)
491 1.20 mjacob IDPRINTF(2, ("\n"));
492 1.10 mjacob if (sdp->isp_devparam[i].dev_enable == 0)
493 1.1 cgd continue;
494 1.1 cgd
495 1.20 mjacob /*
496 1.20 mjacob * It is not safe to run the 1020 in ultra mode.
497 1.20 mjacob */
498 1.20 mjacob if (isp->isp_type == ISP_HA_SCSI_1020 &&
499 1.23 mjacob cj == (ISP_20M_SYNCPARMS & 0xff)) {
500 1.23 mjacob PRINTF("%s: an ISP1020 set to Ultra Speed- derating.\n",
501 1.20 mjacob isp->isp_name);
502 1.20 mjacob sdp->isp_devparam[i].sync_offset =
503 1.20 mjacob ISP_10M_SYNCPARMS >> 8;
504 1.20 mjacob sdp->isp_devparam[i].sync_period =
505 1.20 mjacob ISP_10M_SYNCPARMS & 0xff;
506 1.20 mjacob }
507 1.1 cgd mbs.param[0] = MBOX_SET_TARGET_PARAMS;
508 1.1 cgd mbs.param[1] = i << 8;
509 1.10 mjacob mbs.param[2] = sdp->isp_devparam[i].dev_flags << 8;
510 1.1 cgd mbs.param[3] =
511 1.10 mjacob (sdp->isp_devparam[i].sync_offset << 8) |
512 1.10 mjacob (sdp->isp_devparam[i].sync_period);
513 1.10 mjacob
514 1.23 mjacob IDPRINTF(3, ("\n%s: target %d flags %x offset %x period %x\n",
515 1.10 mjacob isp->isp_name, i, sdp->isp_devparam[i].dev_flags,
516 1.10 mjacob sdp->isp_devparam[i].sync_offset,
517 1.10 mjacob sdp->isp_devparam[i].sync_period));
518 1.10 mjacob isp_mboxcmd(isp, &mbs);
519 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
520 1.23 mjacob PRINTF("%s: failed to set parameters for target %d\n",
521 1.10 mjacob isp->isp_name, i);
522 1.23 mjacob PRINTF("%s: flags %x offset %x period %x\n",
523 1.10 mjacob isp->isp_name, sdp->isp_devparam[i].dev_flags,
524 1.10 mjacob sdp->isp_devparam[i].sync_offset,
525 1.10 mjacob sdp->isp_devparam[i].sync_period);
526 1.10 mjacob mbs.param[0] = MBOX_SET_TARGET_PARAMS;
527 1.10 mjacob mbs.param[1] = i << 8;
528 1.10 mjacob mbs.param[2] = DPARM_DEFAULT << 8;
529 1.10 mjacob mbs.param[3] = ISP_10M_SYNCPARMS;
530 1.10 mjacob isp_mboxcmd(isp, &mbs);
531 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
532 1.23 mjacob ISP_UNLOCK(isp);
533 1.23 mjacob PRINTF("%s: failed even to set defaults\n",
534 1.10 mjacob isp->isp_name);
535 1.10 mjacob return;
536 1.10 mjacob }
537 1.1 cgd }
538 1.1 cgd for (l = 0; l < MAX_LUNS; l++) {
539 1.1 cgd mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
540 1.1 cgd mbs.param[1] = (i << 8) | l;
541 1.10 mjacob mbs.param[2] = sdp->isp_max_queue_depth;
542 1.10 mjacob mbs.param[3] = sdp->isp_devparam[i].exc_throttle;
543 1.10 mjacob isp_mboxcmd(isp, &mbs);
544 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
545 1.23 mjacob ISP_UNLOCK(isp);
546 1.10 mjacob isp_dumpregs(isp, "failed to set device queue "
547 1.10 mjacob "parameters");
548 1.1 cgd return;
549 1.1 cgd }
550 1.1 cgd }
551 1.1 cgd }
552 1.1 cgd
553 1.7 thorpej /*
554 1.7 thorpej * Set up DMA for the request and result mailboxes.
555 1.7 thorpej */
556 1.7 thorpej if (ISP_MBOXDMASETUP(isp)) {
557 1.23 mjacob ISP_UNLOCK(isp);
558 1.23 mjacob PRINTF("%s: can't setup dma mailboxes\n", isp->isp_name);
559 1.1 cgd return;
560 1.1 cgd }
561 1.10 mjacob
562 1.1 cgd mbs.param[0] = MBOX_INIT_RES_QUEUE;
563 1.23 mjacob mbs.param[1] = RESULT_QUEUE_LEN;
564 1.7 thorpej mbs.param[2] = (u_int16_t) (isp->isp_result_dma >> 16);
565 1.7 thorpej mbs.param[3] = (u_int16_t) (isp->isp_result_dma & 0xffff);
566 1.1 cgd mbs.param[4] = 0;
567 1.6 mjacob mbs.param[5] = 0;
568 1.10 mjacob isp_mboxcmd(isp, &mbs);
569 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
570 1.23 mjacob ISP_UNLOCK(isp);
571 1.10 mjacob isp_dumpregs(isp, "set of response queue failed");
572 1.1 cgd return;
573 1.1 cgd }
574 1.1 cgd isp->isp_residx = 0;
575 1.1 cgd
576 1.1 cgd mbs.param[0] = MBOX_INIT_REQ_QUEUE;
577 1.23 mjacob mbs.param[1] = RQUEST_QUEUE_LEN;
578 1.7 thorpej mbs.param[2] = (u_int16_t) (isp->isp_rquest_dma >> 16);
579 1.7 thorpej mbs.param[3] = (u_int16_t) (isp->isp_rquest_dma & 0xffff);
580 1.1 cgd mbs.param[4] = 0;
581 1.10 mjacob mbs.param[5] = 0;
582 1.10 mjacob isp_mboxcmd(isp, &mbs);
583 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
584 1.23 mjacob ISP_UNLOCK(isp);
585 1.10 mjacob isp_dumpregs(isp, "set of request queue failed");
586 1.1 cgd return;
587 1.1 cgd }
588 1.1 cgd isp->isp_reqidx = 0;
589 1.1 cgd
590 1.1 cgd /*
591 1.1 cgd * Unfortunately, this is the only way right now for
592 1.1 cgd * forcing a sync renegotiation. If we boot off of
593 1.1 cgd * an Alpha, it's put the chip in SYNC mode, but we
594 1.1 cgd * haven't necessarily set up the parameters the
595 1.1 cgd * same, so we'll have to yank the reset line to
596 1.1 cgd * get everyone to renegotiate.
597 1.1 cgd */
598 1.1 cgd
599 1.1 cgd mbs.param[0] = MBOX_BUS_RESET;
600 1.1 cgd mbs.param[1] = 2;
601 1.10 mjacob isp_mboxcmd(isp, &mbs);
602 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
603 1.23 mjacob ISP_UNLOCK(isp);
604 1.10 mjacob isp_dumpregs(isp, "SCSI bus reset failed");
605 1.1 cgd }
606 1.10 mjacob /*
607 1.10 mjacob * This is really important to have set after a bus reset.
608 1.10 mjacob */
609 1.1 cgd isp->isp_sendmarker = 1;
610 1.23 mjacob ISP_UNLOCK(isp);
611 1.1 cgd isp->isp_state = ISP_INITSTATE;
612 1.1 cgd }
613 1.1 cgd
614 1.10 mjacob static void
615 1.10 mjacob isp_fibre_init(isp)
616 1.10 mjacob struct ispsoftc *isp;
617 1.10 mjacob {
618 1.10 mjacob fcparam *fcp;
619 1.10 mjacob isp_icb_t *icbp;
620 1.10 mjacob mbreg_t mbs;
621 1.23 mjacob int count;
622 1.23 mjacob u_int8_t lwfs;
623 1.23 mjacob ISP_LOCKVAL_DECL;
624 1.10 mjacob
625 1.10 mjacob fcp = isp->isp_param;
626 1.10 mjacob
627 1.10 mjacob fcp->isp_retry_count = 0;
628 1.10 mjacob fcp->isp_retry_delay = 1;
629 1.10 mjacob
630 1.23 mjacob ISP_LOCK(isp);
631 1.10 mjacob mbs.param[0] = MBOX_SET_RETRY_COUNT;
632 1.10 mjacob mbs.param[1] = fcp->isp_retry_count;
633 1.10 mjacob mbs.param[2] = fcp->isp_retry_delay;
634 1.10 mjacob isp_mboxcmd(isp, &mbs);
635 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
636 1.23 mjacob ISP_UNLOCK(isp);
637 1.10 mjacob isp_dumpregs(isp, "failed to set retry count and delay");
638 1.10 mjacob return;
639 1.10 mjacob }
640 1.10 mjacob
641 1.10 mjacob if (ISP_MBOXDMASETUP(isp)) {
642 1.23 mjacob ISP_UNLOCK(isp);
643 1.23 mjacob PRINTF("%s: can't setup DMA for mailboxes\n", isp->isp_name);
644 1.10 mjacob return;
645 1.10 mjacob }
646 1.10 mjacob
647 1.10 mjacob icbp = (isp_icb_t *) fcp->isp_scratch;
648 1.10 mjacob bzero(icbp, sizeof (*icbp));
649 1.10 mjacob #if 0
650 1.10 mjacob icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
651 1.10 mjacob MAKE_NODE_NAME(isp, icbp);
652 1.23 mjacob icbp->icb_rqstqlen = RQUEST_QUEUE_LEN;
653 1.23 mjacob icbp->icb_rsltqlen = RESULT_QUEUE_LEN;
654 1.10 mjacob icbp->icb_rqstaddr[0] = (u_int16_t) (isp->isp_rquest_dma & 0xffff);
655 1.10 mjacob icbp->icb_rqstaddr[1] = (u_int16_t) (isp->isp_rquest_dma >> 16);
656 1.10 mjacob icbp->icb_respaddr[0] = (u_int16_t) (isp->isp_result_dma & 0xffff);
657 1.10 mjacob icbp->icb_respaddr[1] = (u_int16_t) (isp->isp_result_dma >> 16);
658 1.10 mjacob #endif
659 1.10 mjacob icbp->icb_version = 1;
660 1.10 mjacob icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
661 1.10 mjacob icbp->icb_maxalloc = 256;
662 1.10 mjacob icbp->icb_execthrottle = 16;
663 1.10 mjacob icbp->icb_retry_delay = 5;
664 1.10 mjacob icbp->icb_retry_count = 0;
665 1.10 mjacob MAKE_NODE_NAME(isp, icbp);
666 1.23 mjacob icbp->icb_rqstqlen = RQUEST_QUEUE_LEN;
667 1.23 mjacob icbp->icb_rsltqlen = RESULT_QUEUE_LEN;
668 1.10 mjacob icbp->icb_rqstaddr[0] = (u_int16_t) (isp->isp_rquest_dma & 0xffff);
669 1.10 mjacob icbp->icb_rqstaddr[1] = (u_int16_t) (isp->isp_rquest_dma >> 16);
670 1.10 mjacob icbp->icb_respaddr[0] = (u_int16_t) (isp->isp_result_dma & 0xffff);
671 1.10 mjacob icbp->icb_respaddr[1] = (u_int16_t) (isp->isp_result_dma >> 16);
672 1.10 mjacob
673 1.10 mjacob mbs.param[0] = MBOX_INIT_FIRMWARE;
674 1.10 mjacob mbs.param[1] = 0;
675 1.10 mjacob mbs.param[2] = (u_int16_t) (fcp->isp_scdma >> 16);
676 1.10 mjacob mbs.param[3] = (u_int16_t) (fcp->isp_scdma & 0xffff);
677 1.10 mjacob mbs.param[4] = 0;
678 1.10 mjacob mbs.param[5] = 0;
679 1.10 mjacob mbs.param[6] = 0;
680 1.10 mjacob mbs.param[7] = 0;
681 1.10 mjacob isp_mboxcmd(isp, &mbs);
682 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
683 1.23 mjacob ISP_UNLOCK(isp);
684 1.10 mjacob isp_dumpregs(isp, "INIT FIRMWARE failed");
685 1.10 mjacob return;
686 1.10 mjacob }
687 1.10 mjacob isp->isp_reqidx = 0;
688 1.10 mjacob isp->isp_residx = 0;
689 1.10 mjacob
690 1.10 mjacob /*
691 1.23 mjacob * Wait up to 12 seconds for FW to go to READY state.
692 1.23 mjacob * This used to be 3 seconds, but that lost.
693 1.10 mjacob *
694 1.10 mjacob * This is all very much not right. The problem here
695 1.10 mjacob * is that the cable may not be plugged in, or there
696 1.10 mjacob * may be many many members of the loop that haven't
697 1.10 mjacob * been logged into.
698 1.10 mjacob *
699 1.10 mjacob * This model of doing things doesn't support dynamic
700 1.10 mjacob * attachment, so we just plain lose (for now).
701 1.10 mjacob */
702 1.23 mjacob lwfs = FW_CONFIG_WAIT;
703 1.23 mjacob for (count = 0; count < 12000; count++) {
704 1.10 mjacob isp_fw_state(isp);
705 1.23 mjacob if (lwfs != fcp->isp_fwstate) {
706 1.23 mjacob PRINTF("%s: Firmware State %s -> %s\n", isp->isp_name,
707 1.23 mjacob fw_statename(lwfs), fw_statename(fcp->isp_fwstate));
708 1.23 mjacob lwfs = fcp->isp_fwstate;
709 1.23 mjacob }
710 1.23 mjacob if (fcp->isp_fwstate == FW_READY) {
711 1.10 mjacob break;
712 1.23 mjacob }
713 1.23 mjacob SYS_DELAY(1000); /* wait one millisecond */
714 1.10 mjacob }
715 1.13 mjacob isp->isp_sendmarker = 1;
716 1.10 mjacob
717 1.10 mjacob /*
718 1.23 mjacob * Get our Loop ID
719 1.23 mjacob * (if possible)
720 1.10 mjacob */
721 1.23 mjacob if (fcp->isp_fwstate == FW_READY) {
722 1.10 mjacob mbs.param[0] = MBOX_GET_LOOP_ID;
723 1.10 mjacob isp_mboxcmd(isp, &mbs);
724 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
725 1.10 mjacob isp_dumpregs(isp, "GET LOOP ID failed");
726 1.23 mjacob ISP_UNLOCK(isp);
727 1.10 mjacob return;
728 1.10 mjacob }
729 1.10 mjacob fcp->isp_loopid = mbs.param[1];
730 1.10 mjacob if (fcp->isp_loopid) {
731 1.23 mjacob PRINTF("%s: Loop ID 0x%x\n", isp->isp_name,
732 1.10 mjacob fcp->isp_loopid);
733 1.10 mjacob }
734 1.23 mjacob isp->isp_state = ISP_INITSTATE;
735 1.10 mjacob } else {
736 1.23 mjacob PRINTF("%s: failed to go to FW READY state- will not attach\n",
737 1.23 mjacob isp->isp_name);
738 1.23 mjacob }
739 1.23 mjacob ISP_UNLOCK(isp);
740 1.1 cgd }
741 1.1 cgd
742 1.1 cgd /*
743 1.23 mjacob * Free any associated resources prior to decommissioning and
744 1.23 mjacob * set the card to a known state (so it doesn't wake up and kick
745 1.23 mjacob * us when we aren't expecting it to).
746 1.23 mjacob *
747 1.23 mjacob * Locks are held before coming here.
748 1.1 cgd */
749 1.1 cgd void
750 1.1 cgd isp_uninit(isp)
751 1.1 cgd struct ispsoftc *isp;
752 1.1 cgd {
753 1.23 mjacob /*
754 1.23 mjacob * Leave with interrupts disabled.
755 1.23 mjacob */
756 1.23 mjacob DISABLE_INTS(isp);
757 1.1 cgd
758 1.1 cgd /*
759 1.23 mjacob * Stop the watchdog timer (if started).
760 1.1 cgd */
761 1.23 mjacob STOP_WATCHDOG(isp_watch, isp);
762 1.1 cgd }
763 1.1 cgd
764 1.23 mjacob
765 1.1 cgd /*
766 1.23 mjacob * Start a command. Locking is assumed done in the caller.
767 1.1 cgd */
768 1.23 mjacob
769 1.23 mjacob int32_t
770 1.1 cgd ispscsicmd(xs)
771 1.23 mjacob ISP_SCSI_XFER_T *xs;
772 1.1 cgd {
773 1.1 cgd struct ispsoftc *isp;
774 1.1 cgd u_int8_t iptr, optr;
775 1.10 mjacob union {
776 1.10 mjacob ispreq_t *_reqp;
777 1.10 mjacob ispreqt2_t *_t2reqp;
778 1.10 mjacob } _u;
779 1.10 mjacob #define reqp _u._reqp
780 1.10 mjacob #define t2reqp _u._t2reqp
781 1.16 mjacob #define UZSIZE max(sizeof (ispreq_t), sizeof (ispreqt2_t))
782 1.23 mjacob int i;
783 1.1 cgd
784 1.23 mjacob XS_INITERR(xs);
785 1.23 mjacob isp = XS_ISP(xs);
786 1.1 cgd
787 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
788 1.23 mjacob if (XS_CDBLEN(xs) > 12) {
789 1.23 mjacob PRINTF("%s: unsupported cdb length for fibre (%d)\n",
790 1.23 mjacob isp->isp_name, XS_CDBLEN(xs));
791 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
792 1.23 mjacob return (CMD_COMPLETE);
793 1.10 mjacob }
794 1.10 mjacob }
795 1.1 cgd optr = ISP_READ(isp, OUTMAILBOX4);
796 1.1 cgd iptr = isp->isp_reqidx;
797 1.1 cgd
798 1.10 mjacob reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
799 1.23 mjacob iptr = (iptr + 1) & (RQUEST_QUEUE_LEN - 1);
800 1.1 cgd if (iptr == optr) {
801 1.23 mjacob PRINTF("%s: Request Queue Overflow\n", isp->isp_name);
802 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
803 1.23 mjacob return (CMD_EAGAIN);
804 1.1 cgd }
805 1.1 cgd
806 1.23 mjacob if (isp->isp_type & ISP_HA_FC) {
807 1.13 mjacob DISABLE_INTS(isp);
808 1.23 mjacob }
809 1.13 mjacob
810 1.1 cgd if (isp->isp_sendmarker) {
811 1.10 mjacob ispmarkreq_t *marker = (ispmarkreq_t *) reqp;
812 1.1 cgd
813 1.1 cgd bzero((void *) marker, sizeof (*marker));
814 1.1 cgd marker->req_header.rqs_entry_count = 1;
815 1.1 cgd marker->req_header.rqs_entry_type = RQSTYPE_MARKER;
816 1.1 cgd marker->req_modifier = SYNC_ALL;
817 1.1 cgd
818 1.1 cgd isp->isp_sendmarker = 0;
819 1.1 cgd
820 1.23 mjacob if (((iptr + 1) & (RQUEST_QUEUE_LEN - 1)) == optr) {
821 1.1 cgd ISP_WRITE(isp, INMAILBOX4, iptr);
822 1.1 cgd isp->isp_reqidx = iptr;
823 1.13 mjacob
824 1.23 mjacob if (isp->isp_type & ISP_HA_FC) {
825 1.13 mjacob ENABLE_INTS(isp);
826 1.23 mjacob }
827 1.23 mjacob PRINTF("%s: Request Queue Overflow+\n", isp->isp_name);
828 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
829 1.23 mjacob return (CMD_EAGAIN);
830 1.1 cgd }
831 1.10 mjacob reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
832 1.23 mjacob iptr = (iptr + 1) & (RQUEST_QUEUE_LEN - 1);
833 1.1 cgd }
834 1.1 cgd
835 1.16 mjacob bzero((void *) reqp, UZSIZE);
836 1.10 mjacob reqp->req_header.rqs_entry_count = 1;
837 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
838 1.10 mjacob reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
839 1.10 mjacob } else {
840 1.10 mjacob reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
841 1.10 mjacob }
842 1.10 mjacob reqp->req_header.rqs_flags = 0;
843 1.10 mjacob reqp->req_header.rqs_seqno = isp->isp_seqno++;
844 1.1 cgd
845 1.23 mjacob for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
846 1.1 cgd if (isp->isp_xflist[i] == NULL)
847 1.1 cgd break;
848 1.1 cgd }
849 1.23 mjacob if (i == RQUEST_QUEUE_LEN) {
850 1.23 mjacob if (isp->isp_type & ISP_HA_FC)
851 1.23 mjacob ENABLE_INTS(isp);
852 1.23 mjacob PRINTF("%s: ran out of xflist pointers?????\n", isp->isp_name);
853 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
854 1.23 mjacob return (CMD_EAGAIN);
855 1.1 cgd } else {
856 1.10 mjacob /*
857 1.10 mjacob * Never have a handle that is zero, so
858 1.10 mjacob * set req_handle off by one.
859 1.10 mjacob */
860 1.1 cgd isp->isp_xflist[i] = xs;
861 1.10 mjacob reqp->req_handle = i+1;
862 1.1 cgd }
863 1.1 cgd
864 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
865 1.10 mjacob /*
866 1.10 mjacob * See comment in isp_intr
867 1.10 mjacob */
868 1.23 mjacob XS_RESID(xs) = 0;
869 1.10 mjacob /*
870 1.16 mjacob * Fibre Channel always requires some kind of tag.
871 1.23 mjacob * If we're marked as "Can't Tag", just do simple
872 1.23 mjacob * instead of ordered tags. It's pretty clear to me
873 1.23 mjacob * that we shouldn't do head of queue tagging in
874 1.23 mjacob * this case.
875 1.10 mjacob */
876 1.23 mjacob if (XS_CANTAG(xs)) {
877 1.23 mjacob t2reqp->req_flags = XS_KINDOF_TAG(xs);
878 1.10 mjacob } else {
879 1.23 mjacob t2reqp->req_flags = REQFLAG_STAG;
880 1.10 mjacob }
881 1.10 mjacob } else {
882 1.23 mjacob sdparam *sdp = (sdparam *)isp->isp_param;
883 1.23 mjacob if ((sdp->isp_devparam[XS_TGT(xs)].dev_flags & DPARM_TQING) &&
884 1.23 mjacob XS_CANTAG(xs)) {
885 1.23 mjacob reqp->req_flags = XS_KINDOF_TAG(xs);
886 1.23 mjacob } else {
887 1.10 mjacob reqp->req_flags = 0;
888 1.10 mjacob }
889 1.10 mjacob }
890 1.23 mjacob reqp->req_lun_trn = XS_LUN(xs);
891 1.23 mjacob reqp->req_target = XS_TGT(xs);
892 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
893 1.23 mjacob reqp->req_cdblen = XS_CDBLEN(xs);
894 1.10 mjacob }
895 1.23 mjacob bcopy((void *)XS_CDBP(xs), reqp->req_cdb, XS_CDBLEN(xs));
896 1.1 cgd
897 1.23 mjacob IDPRINTF(5, ("%s(%d.%d): START%d cmd 0x%x datalen %d\n", isp->isp_name,
898 1.23 mjacob XS_TGT(xs), XS_LUN(xs), reqp->req_header.rqs_seqno,
899 1.23 mjacob reqp->req_cdb[0], XS_XFRLEN(xs)));
900 1.1 cgd
901 1.23 mjacob reqp->req_time = XS_TIME(xs) / 1000;
902 1.23 mjacob if (reqp->req_time == 0 && XS_TIME(xs))
903 1.10 mjacob reqp->req_time = 1;
904 1.10 mjacob if (ISP_DMASETUP(isp, xs, reqp, &iptr, optr)) {
905 1.13 mjacob if (isp->isp_type & ISP_HA_FC)
906 1.13 mjacob ENABLE_INTS(isp);
907 1.23 mjacob /* dmasetup sets actual error */
908 1.23 mjacob return (CMD_COMPLETE);
909 1.1 cgd }
910 1.23 mjacob XS_SETERR(xs, HBA_NOERROR);
911 1.1 cgd ISP_WRITE(isp, INMAILBOX4, iptr);
912 1.1 cgd isp->isp_reqidx = iptr;
913 1.23 mjacob if (isp->isp_type & ISP_HA_FC) {
914 1.13 mjacob ENABLE_INTS(isp);
915 1.3 cgd }
916 1.23 mjacob isp->isp_nactive++;
917 1.23 mjacob return (CMD_QUEUED);
918 1.10 mjacob #undef reqp
919 1.10 mjacob #undef t2reqp
920 1.1 cgd }
921 1.1 cgd
922 1.1 cgd /*
923 1.23 mjacob * isp control
924 1.23 mjacob * Locks (ints blocked) assumed held.
925 1.1 cgd */
926 1.1 cgd
927 1.1 cgd int
928 1.23 mjacob isp_control(isp, ctl, arg)
929 1.1 cgd struct ispsoftc *isp;
930 1.23 mjacob ispctl_t ctl;
931 1.23 mjacob void *arg;
932 1.1 cgd {
933 1.23 mjacob ISP_SCSI_XFER_T *xs;
934 1.23 mjacob mbreg_t mbs;
935 1.23 mjacob int i;
936 1.3 cgd
937 1.23 mjacob switch (ctl) {
938 1.23 mjacob default:
939 1.23 mjacob PRINTF("%s: isp_control unknown control op %x\n",
940 1.23 mjacob isp->isp_name, ctl);
941 1.23 mjacob break;
942 1.3 cgd
943 1.23 mjacob case ISPCTL_RESET_BUS:
944 1.23 mjacob /*
945 1.23 mjacob * Right now, for Fibre, we'll punt on loop reset.
946 1.23 mjacob * The reason is that it takes a really long time
947 1.23 mjacob * to go through the renegotiation after a LIP,
948 1.23 mjacob * and we really have to hang out until it's done
949 1.23 mjacob * to see what's there after a LIP- until the
950 1.23 mjacob * LIP is done and the loop comes back up,
951 1.23 mjacob * commands just fail (and, yes, we could handle
952 1.23 mjacob * that a little better).
953 1.23 mjacob */
954 1.23 mjacob if (isp->isp_type & ISP_HA_FC) {
955 1.23 mjacob PRINTF("%s: Skipping FC resets\n", isp->isp_name);
956 1.3 cgd return (0);
957 1.23 mjacob }
958 1.23 mjacob mbs.param[0] = MBOX_BUS_RESET;
959 1.23 mjacob mbs.param[1] = 2; /* 'delay', in seconds */
960 1.23 mjacob isp_mboxcmd(isp, &mbs);
961 1.23 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
962 1.23 mjacob isp_dumpregs(isp, "isp_control SCSI bus reset failed");
963 1.23 mjacob break;
964 1.23 mjacob }
965 1.23 mjacob /*
966 1.23 mjacob * This is really important to have set after a bus reset.
967 1.23 mjacob */
968 1.23 mjacob isp->isp_sendmarker = 1;
969 1.23 mjacob PRINTF("%s: Bus Reset\n", isp->isp_name);
970 1.23 mjacob return (0);
971 1.23 mjacob
972 1.23 mjacob case ISPCTL_RESET_DEV:
973 1.23 mjacob /*
974 1.23 mjacob * Note that under parallel SCSI, this issues a BDR message.
975 1.23 mjacob * Under FC, we could probably be using ABORT TASK SET
976 1.23 mjacob * command.
977 1.23 mjacob */
978 1.23 mjacob
979 1.23 mjacob mbs.param[0] = MBOX_ABORT_TARGET;
980 1.23 mjacob mbs.param[1] = ((long)arg) << 8;
981 1.23 mjacob mbs.param[2] = 2; /* 'delay', in seconds */
982 1.23 mjacob isp_mboxcmd(isp, &mbs);
983 1.23 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
984 1.23 mjacob isp_dumpregs(isp, "SCSI Target reset failed");
985 1.23 mjacob break;
986 1.23 mjacob }
987 1.23 mjacob PRINTF("%s: Target %d Reset Succeeded\n", isp->isp_name,
988 1.23 mjacob (int) ((long) arg));
989 1.23 mjacob isp->isp_sendmarker = 1;
990 1.23 mjacob return (0);
991 1.23 mjacob
992 1.23 mjacob case ISPCTL_ABORT_CMD:
993 1.23 mjacob xs = (ISP_SCSI_XFER_T *) arg;
994 1.23 mjacob for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
995 1.23 mjacob if (xs == isp->isp_xflist[i]) {
996 1.23 mjacob break;
997 1.23 mjacob }
998 1.23 mjacob }
999 1.23 mjacob if (i == RQUEST_QUEUE_LEN) {
1000 1.23 mjacob PRINTF("%s: isp_control- cannot find command to abort "
1001 1.23 mjacob "in active list\n", isp->isp_name);
1002 1.23 mjacob break;
1003 1.23 mjacob }
1004 1.23 mjacob mbs.param[0] = MBOX_ABORT;
1005 1.23 mjacob mbs.param[1] = XS_TGT(xs) | XS_LUN(xs);
1006 1.23 mjacob mbs.param[2] = (i+1) >> 16;
1007 1.23 mjacob mbs.param[3] = (i+1) & 0xffff;
1008 1.23 mjacob isp_mboxcmd(isp, &mbs);
1009 1.23 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1010 1.23 mjacob PRINTF("%s: isp_control MBOX_ABORT failure (code %x)\n",
1011 1.23 mjacob isp->isp_name, mbs.param[0]);
1012 1.23 mjacob break;
1013 1.23 mjacob }
1014 1.23 mjacob PRINTF("%s: command for target %d lun %d was aborted\n",
1015 1.23 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
1016 1.23 mjacob return (0);
1017 1.1 cgd }
1018 1.23 mjacob return (-1);
1019 1.1 cgd }
1020 1.1 cgd
1021 1.23 mjacob /*
1022 1.23 mjacob * Interrupt Service Routine(s).
1023 1.23 mjacob *
1024 1.23 mjacob * External (OS) framework has done the appropriate locking,
1025 1.23 mjacob * and the locking will be held throughout this function.
1026 1.23 mjacob */
1027 1.23 mjacob
1028 1.1 cgd int
1029 1.1 cgd isp_intr(arg)
1030 1.1 cgd void *arg;
1031 1.1 cgd {
1032 1.23 mjacob ISP_SCSI_XFER_T *clist[RQUEST_QUEUE_LEN], *xs;
1033 1.1 cgd struct ispsoftc *isp = arg;
1034 1.1 cgd u_int16_t iptr, optr, isr;
1035 1.23 mjacob int i, ndone = 0;
1036 1.1 cgd
1037 1.1 cgd isr = ISP_READ(isp, BIU_ISR);
1038 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
1039 1.10 mjacob if (isr == 0 || (isr & BIU2100_ISR_RISC_INT) == 0) {
1040 1.10 mjacob if (isr) {
1041 1.20 mjacob IDPRINTF(4, ("%s: isp_intr isr=%x\n",
1042 1.10 mjacob isp->isp_name, isr));
1043 1.10 mjacob }
1044 1.10 mjacob return (0);
1045 1.10 mjacob }
1046 1.10 mjacob } else {
1047 1.10 mjacob if (isr == 0 || (isr & BIU_ISR_RISC_INT) == 0) {
1048 1.10 mjacob if (isr) {
1049 1.20 mjacob IDPRINTF(4, ("%s: isp_intr isr=%x\n",
1050 1.10 mjacob isp->isp_name, isr));
1051 1.10 mjacob }
1052 1.10 mjacob return (0);
1053 1.1 cgd }
1054 1.1 cgd }
1055 1.1 cgd
1056 1.1 cgd optr = isp->isp_residx;
1057 1.1 cgd if (ISP_READ(isp, BIU_SEMA) & 1) {
1058 1.23 mjacob u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0);
1059 1.23 mjacob switch (mbox) {
1060 1.1 cgd case ASYNC_BUS_RESET:
1061 1.23 mjacob PRINTF("%s: SCSI bus reset detected\n", isp->isp_name);
1062 1.23 mjacob isp->isp_sendmarker = 1;
1063 1.23 mjacob break;
1064 1.23 mjacob case ASYNC_SYSTEM_ERROR:
1065 1.23 mjacob mbox = ISP_READ(isp, OUTMAILBOX1);
1066 1.23 mjacob PRINTF("%s: Internal System Error RISC Addr %x\n",
1067 1.23 mjacob isp->isp_name, mbox);
1068 1.23 mjacob break;
1069 1.23 mjacob case ASYNC_RQS_XFER_ERR:
1070 1.23 mjacob PRINTF("%s: Request Queue Transfer Error\n",
1071 1.23 mjacob isp->isp_name);
1072 1.23 mjacob break;
1073 1.23 mjacob case ASYNC_RSP_XFER_ERR:
1074 1.23 mjacob PRINTF("%s: Response Queue Transfer Error\n",
1075 1.23 mjacob isp->isp_name);
1076 1.23 mjacob break;
1077 1.23 mjacob case ASYNC_QWAKEUP:
1078 1.23 mjacob /* don't need to be chatty */
1079 1.23 mjacob mbox = ISP_READ(isp, OUTMAILBOX4);
1080 1.23 mjacob break;
1081 1.1 cgd case ASYNC_TIMEOUT_RESET:
1082 1.23 mjacob PRINTF("%s: timeout initiated SCSI bus reset\n",
1083 1.23 mjacob isp->isp_name);
1084 1.1 cgd isp->isp_sendmarker = 1;
1085 1.1 cgd break;
1086 1.10 mjacob case ASYNC_LIP_OCCURRED:
1087 1.23 mjacob PRINTF("%s: LIP occurred\n", isp->isp_name);
1088 1.10 mjacob break;
1089 1.10 mjacob case ASYNC_LOOP_UP:
1090 1.23 mjacob PRINTF("%s: Loop UP\n", isp->isp_name);
1091 1.10 mjacob break;
1092 1.10 mjacob case ASYNC_LOOP_DOWN:
1093 1.23 mjacob PRINTF("%s: Loop DOWN\n", isp->isp_name);
1094 1.16 mjacob break;
1095 1.16 mjacob case ASYNC_LOOP_RESET:
1096 1.23 mjacob PRINTF("%s: Loop RESET\n", isp->isp_name);
1097 1.10 mjacob break;
1098 1.1 cgd default:
1099 1.23 mjacob PRINTF("%s: async %x\n", isp->isp_name, mbox);
1100 1.1 cgd break;
1101 1.1 cgd }
1102 1.1 cgd ISP_WRITE(isp, BIU_SEMA, 0);
1103 1.1 cgd }
1104 1.1 cgd
1105 1.10 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
1106 1.10 mjacob iptr = ISP_READ(isp, OUTMAILBOX5);
1107 1.10 mjacob if (optr == iptr) {
1108 1.20 mjacob IDPRINTF(4, ("why intr? isr %x iptr %x optr %x\n",
1109 1.10 mjacob isr, optr, iptr));
1110 1.10 mjacob }
1111 1.10 mjacob ENABLE_INTS(isp);
1112 1.10 mjacob
1113 1.1 cgd while (optr != iptr) {
1114 1.1 cgd ispstatusreq_t *sp;
1115 1.1 cgd int buddaboom = 0;
1116 1.1 cgd
1117 1.7 thorpej sp = (ispstatusreq_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
1118 1.1 cgd
1119 1.23 mjacob optr = (optr + 1) & (RESULT_QUEUE_LEN - 1);
1120 1.1 cgd if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) {
1121 1.23 mjacob PRINTF("%s: not RESPONSE in RESPONSE Queue (0x%x)\n",
1122 1.1 cgd isp->isp_name, sp->req_header.rqs_entry_type);
1123 1.1 cgd if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) {
1124 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
1125 1.1 cgd continue;
1126 1.1 cgd }
1127 1.1 cgd buddaboom = 1;
1128 1.1 cgd }
1129 1.1 cgd
1130 1.1 cgd if (sp->req_header.rqs_flags & 0xf) {
1131 1.1 cgd if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
1132 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
1133 1.1 cgd continue;
1134 1.1 cgd }
1135 1.23 mjacob PRINTF("%s: rqs_flags=%x", isp->isp_name,
1136 1.1 cgd sp->req_header.rqs_flags & 0xf);
1137 1.23 mjacob if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
1138 1.23 mjacob PRINTF("%s: internal queues full\n",
1139 1.23 mjacob isp->isp_name);
1140 1.23 mjacob /* XXXX: this command *could* get restarted */
1141 1.23 mjacob buddaboom++;
1142 1.23 mjacob }
1143 1.23 mjacob if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
1144 1.23 mjacob PRINTF("%s: bad header\n", isp->isp_name);
1145 1.23 mjacob buddaboom++;
1146 1.23 mjacob }
1147 1.23 mjacob if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
1148 1.23 mjacob PRINTF("%s: bad request packet\n",
1149 1.23 mjacob isp->isp_name);
1150 1.23 mjacob buddaboom++;
1151 1.23 mjacob }
1152 1.1 cgd }
1153 1.23 mjacob if (sp->req_handle > RQUEST_QUEUE_LEN || sp->req_handle < 1) {
1154 1.23 mjacob PRINTF("%s: bad request handle %d\n", isp->isp_name,
1155 1.1 cgd sp->req_handle);
1156 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
1157 1.1 cgd continue;
1158 1.1 cgd }
1159 1.23 mjacob xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[sp->req_handle - 1];
1160 1.1 cgd if (xs == NULL) {
1161 1.23 mjacob PRINTF("%s: NULL xs in xflist (handle %x)\n",
1162 1.23 mjacob isp->isp_name, sp->req_handle);
1163 1.23 mjacob isp_dumpxflist(isp);
1164 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
1165 1.1 cgd continue;
1166 1.1 cgd }
1167 1.10 mjacob isp->isp_xflist[sp->req_handle - 1] = NULL;
1168 1.1 cgd if (sp->req_status_flags & RQSTF_BUS_RESET) {
1169 1.1 cgd isp->isp_sendmarker = 1;
1170 1.1 cgd }
1171 1.1 cgd if (buddaboom) {
1172 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
1173 1.1 cgd }
1174 1.23 mjacob XS_STS(xs) = sp->req_scsi_status & 0xff;
1175 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
1176 1.10 mjacob if (sp->req_state_flags & RQSF_GOT_SENSE) {
1177 1.23 mjacob bcopy(sp->req_sense_data, XS_SNSP(xs),
1178 1.23 mjacob XS_SNSLEN(xs));
1179 1.23 mjacob XS_SNS_IS_VALID(xs);
1180 1.10 mjacob }
1181 1.10 mjacob } else {
1182 1.23 mjacob if (XS_STS(xs) == SCSI_CHECK) {
1183 1.23 mjacob XS_SNS_IS_VALID(xs);
1184 1.23 mjacob bcopy(sp->req_sense_data, XS_SNSP(xs),
1185 1.23 mjacob XS_SNSLEN(xs));
1186 1.10 mjacob sp->req_state_flags |= RQSF_GOT_SENSE;
1187 1.10 mjacob }
1188 1.1 cgd }
1189 1.23 mjacob if (XS_NOERR(xs) && XS_STS(xs) == SCSI_BUSY) {
1190 1.23 mjacob XS_SETERR(xs, HBA_TGTBSY);
1191 1.10 mjacob }
1192 1.1 cgd
1193 1.1 cgd if (sp->req_header.rqs_entry_type == RQSTYPE_RESPONSE) {
1194 1.23 mjacob if (XS_NOERR(xs) && sp->req_completion_status)
1195 1.23 mjacob isp_parse_status(isp, sp, xs);
1196 1.1 cgd } else {
1197 1.23 mjacob PRINTF("%s: unknown return %x\n", isp->isp_name,
1198 1.1 cgd sp->req_header.rqs_entry_type);
1199 1.23 mjacob if (XS_NOERR(xs))
1200 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
1201 1.1 cgd }
1202 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
1203 1.23 mjacob XS_RESID(xs) = sp->req_resid;
1204 1.10 mjacob } else if (sp->req_scsi_status & RQCS_RU) {
1205 1.23 mjacob XS_RESID(xs) = sp->req_resid;
1206 1.20 mjacob IDPRINTF(4, ("%s: cnt %d rsd %d\n", isp->isp_name,
1207 1.23 mjacob XS_XFRLEN(xs), sp->req_resid));
1208 1.10 mjacob }
1209 1.23 mjacob if (XS_XFRLEN(xs)) {
1210 1.10 mjacob ISP_DMAFREE(isp, xs, sp->req_handle - 1);
1211 1.1 cgd }
1212 1.23 mjacob /*
1213 1.23 mjacob * XXX: If we have a check condition, but no Sense Data,
1214 1.23 mjacob * XXX: mark it as an error (ARQ failed). We need to
1215 1.23 mjacob * XXX: to do a more distinct job because there may
1216 1.23 mjacob * XXX: cases where ARQ is disabled.
1217 1.23 mjacob */
1218 1.23 mjacob if (XS_STS(xs) == SCSI_CHECK && !(XS_IS_SNS_VALID(xs))) {
1219 1.23 mjacob if (XS_NOERR(xs)) {
1220 1.23 mjacob PRINTF("%s: ARQ Failure\n", isp->isp_name);
1221 1.23 mjacob XS_SETERR(xs, HBA_ARQFAIL);
1222 1.23 mjacob }
1223 1.23 mjacob }
1224 1.23 mjacob if ((isp->isp_dblev >= 5) ||
1225 1.23 mjacob (isp->isp_dblev > 2 && !XS_NOERR(xs))) {
1226 1.23 mjacob PRINTF("%s(%d.%d): FIN%d dl%d resid%d STS %x",
1227 1.23 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs),
1228 1.23 mjacob sp->req_header.rqs_seqno, XS_XFRLEN(xs),
1229 1.23 mjacob XS_RESID(xs), XS_STS(xs));
1230 1.10 mjacob if (sp->req_state_flags & RQSF_GOT_SENSE) {
1231 1.23 mjacob PRINTF(" Skey: %x", XS_SNSKEY(xs));
1232 1.23 mjacob if (!(XS_IS_SNS_VALID(xs))) {
1233 1.23 mjacob PRINTF(" BUT NOT SET");
1234 1.10 mjacob }
1235 1.1 cgd }
1236 1.23 mjacob PRINTF(" XS_ERR=0x%x\n", XS_ERR(xs));
1237 1.1 cgd }
1238 1.23 mjacob
1239 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
1240 1.23 mjacob isp->isp_nactive--;
1241 1.23 mjacob if (isp->isp_nactive < 0)
1242 1.23 mjacob isp->isp_nactive = 0;
1243 1.23 mjacob clist[ndone++] = xs; /* defer completion call until later */
1244 1.1 cgd }
1245 1.1 cgd isp->isp_residx = optr;
1246 1.23 mjacob for (i = 0; i < ndone; i++)
1247 1.23 mjacob XS_CMD_DONE(clist[i]);
1248 1.1 cgd return (1);
1249 1.1 cgd }
1250 1.1 cgd
1251 1.1 cgd /*
1252 1.1 cgd * Support routines.
1253 1.1 cgd */
1254 1.1 cgd
1255 1.23 mjacob static void
1256 1.10 mjacob isp_parse_status(isp, sp, xs)
1257 1.1 cgd struct ispsoftc *isp;
1258 1.1 cgd ispstatusreq_t *sp;
1259 1.23 mjacob ISP_SCSI_XFER_T *xs;
1260 1.1 cgd {
1261 1.1 cgd switch (sp->req_completion_status) {
1262 1.1 cgd case RQCS_COMPLETE:
1263 1.23 mjacob XS_SETERR(xs, HBA_NOERROR);
1264 1.23 mjacob return;
1265 1.10 mjacob
1266 1.1 cgd case RQCS_INCOMPLETE:
1267 1.1 cgd if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
1268 1.23 mjacob IDPRINTF(2, ("Selection Timeout\n"));
1269 1.23 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
1270 1.23 mjacob return;
1271 1.1 cgd }
1272 1.23 mjacob PRINTF("%s: incomplete, state %x\n",
1273 1.1 cgd isp->isp_name, sp->req_state_flags);
1274 1.1 cgd break;
1275 1.15 mjacob
1276 1.15 mjacob case RQCS_TRANSPORT_ERROR:
1277 1.23 mjacob PRINTF("%s: transport error\n", isp->isp_name);
1278 1.15 mjacob isp_prtstst(sp);
1279 1.15 mjacob break;
1280 1.15 mjacob
1281 1.10 mjacob case RQCS_DATA_OVERRUN:
1282 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
1283 1.23 mjacob XS_RESID(xs) = sp->req_resid;
1284 1.10 mjacob break;
1285 1.10 mjacob }
1286 1.23 mjacob XS_SETERR(xs, HBA_DATAOVR);
1287 1.23 mjacob return;
1288 1.10 mjacob
1289 1.1 cgd case RQCS_DATA_UNDERRUN:
1290 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
1291 1.23 mjacob XS_RESID(xs) = sp->req_resid;
1292 1.23 mjacob /* an UNDERRUN is not a botch ??? */
1293 1.10 mjacob }
1294 1.23 mjacob XS_SETERR(xs, HBA_NOERROR);
1295 1.23 mjacob return;
1296 1.10 mjacob
1297 1.1 cgd case RQCS_TIMEOUT:
1298 1.23 mjacob XS_SETERR(xs, HBA_CMDTIMEOUT);
1299 1.23 mjacob return;
1300 1.10 mjacob
1301 1.1 cgd case RQCS_RESET_OCCURRED:
1302 1.23 mjacob PRINTF("%s: reset occurred, %d active\n", isp->isp_name,
1303 1.23 mjacob isp->isp_nactive);
1304 1.1 cgd isp->isp_sendmarker = 1;
1305 1.23 mjacob XS_SETERR(xs, HBA_BUSRESET);
1306 1.23 mjacob return;
1307 1.10 mjacob
1308 1.1 cgd case RQCS_ABORTED:
1309 1.23 mjacob PRINTF("%s: command aborted\n", isp->isp_name);
1310 1.1 cgd isp->isp_sendmarker = 1;
1311 1.23 mjacob XS_SETERR(xs, HBA_ABORTED);
1312 1.23 mjacob return;
1313 1.10 mjacob
1314 1.10 mjacob case RQCS_PORT_UNAVAILABLE:
1315 1.10 mjacob /*
1316 1.10 mjacob * No such port on the loop. Moral equivalent of SELTIMEO
1317 1.10 mjacob */
1318 1.23 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
1319 1.23 mjacob return;
1320 1.10 mjacob
1321 1.10 mjacob case RQCS_PORT_LOGGED_OUT:
1322 1.23 mjacob PRINTF("%s: port logout for target %d\n",
1323 1.23 mjacob isp->isp_name, XS_TGT(xs));
1324 1.10 mjacob break;
1325 1.10 mjacob
1326 1.10 mjacob case RQCS_PORT_CHANGED:
1327 1.23 mjacob PRINTF("%s: port changed for target %d\n",
1328 1.23 mjacob isp->isp_name, XS_TGT(xs));
1329 1.10 mjacob break;
1330 1.10 mjacob
1331 1.10 mjacob case RQCS_PORT_BUSY:
1332 1.23 mjacob PRINTF("%s: port busy for target %d\n",
1333 1.23 mjacob isp->isp_name, XS_TGT(xs));
1334 1.23 mjacob XS_SETERR(xs, HBA_TGTBSY);
1335 1.23 mjacob return;
1336 1.10 mjacob
1337 1.1 cgd default:
1338 1.23 mjacob PRINTF("%s: comp status %x\n", isp->isp_name,
1339 1.1 cgd sp->req_completion_status);
1340 1.1 cgd break;
1341 1.1 cgd }
1342 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
1343 1.1 cgd }
1344 1.1 cgd
1345 1.1 cgd #define HINIB(x) ((x) >> 0x4)
1346 1.1 cgd #define LONIB(x) ((x) & 0xf)
1347 1.1 cgd #define MAKNIB(a, b) (((a) << 4) | (b))
1348 1.1 cgd static u_int8_t mbpcnt[] = {
1349 1.10 mjacob MAKNIB(1, 1), /* 0x00: MBOX_NO_OP */
1350 1.10 mjacob MAKNIB(5, 5), /* 0x01: MBOX_LOAD_RAM */
1351 1.10 mjacob MAKNIB(2, 0), /* 0x02: MBOX_EXEC_FIRMWARE */
1352 1.10 mjacob MAKNIB(5, 5), /* 0x03: MBOX_DUMP_RAM */
1353 1.10 mjacob MAKNIB(3, 3), /* 0x04: MBOX_WRITE_RAM_WORD */
1354 1.10 mjacob MAKNIB(2, 3), /* 0x05: MBOX_READ_RAM_WORD */
1355 1.10 mjacob MAKNIB(6, 6), /* 0x06: MBOX_MAILBOX_REG_TEST */
1356 1.10 mjacob MAKNIB(2, 3), /* 0x07: MBOX_VERIFY_CHECKSUM */
1357 1.10 mjacob MAKNIB(1, 3), /* 0x08: MBOX_ABOUT_FIRMWARE */
1358 1.10 mjacob MAKNIB(0, 0), /* 0x09: */
1359 1.10 mjacob MAKNIB(0, 0), /* 0x0a: */
1360 1.10 mjacob MAKNIB(0, 0), /* 0x0b: */
1361 1.10 mjacob MAKNIB(0, 0), /* 0x0c: */
1362 1.10 mjacob MAKNIB(0, 0), /* 0x0d: */
1363 1.10 mjacob MAKNIB(1, 2), /* 0x0e: MBOX_CHECK_FIRMWARE */
1364 1.10 mjacob MAKNIB(0, 0), /* 0x0f: */
1365 1.10 mjacob MAKNIB(5, 5), /* 0x10: MBOX_INIT_REQ_QUEUE */
1366 1.10 mjacob MAKNIB(6, 6), /* 0x11: MBOX_INIT_RES_QUEUE */
1367 1.10 mjacob MAKNIB(4, 4), /* 0x12: MBOX_EXECUTE_IOCB */
1368 1.10 mjacob MAKNIB(2, 2), /* 0x13: MBOX_WAKE_UP */
1369 1.10 mjacob MAKNIB(1, 6), /* 0x14: MBOX_STOP_FIRMWARE */
1370 1.10 mjacob MAKNIB(4, 4), /* 0x15: MBOX_ABORT */
1371 1.10 mjacob MAKNIB(2, 2), /* 0x16: MBOX_ABORT_DEVICE */
1372 1.10 mjacob MAKNIB(3, 3), /* 0x17: MBOX_ABORT_TARGET */
1373 1.10 mjacob MAKNIB(2, 2), /* 0x18: MBOX_BUS_RESET */
1374 1.10 mjacob MAKNIB(2, 3), /* 0x19: MBOX_STOP_QUEUE */
1375 1.10 mjacob MAKNIB(2, 3), /* 0x1a: MBOX_START_QUEUE */
1376 1.10 mjacob MAKNIB(2, 3), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
1377 1.10 mjacob MAKNIB(2, 3), /* 0x1c: MBOX_ABORT_QUEUE */
1378 1.10 mjacob MAKNIB(2, 4), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
1379 1.10 mjacob MAKNIB(0, 0), /* 0x1e: */
1380 1.10 mjacob MAKNIB(1, 3), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
1381 1.10 mjacob MAKNIB(1, 2), /* 0x20: MBOX_GET_INIT_SCSI_ID */
1382 1.10 mjacob MAKNIB(1, 2), /* 0x21: MBOX_GET_SELECT_TIMEOUT */
1383 1.10 mjacob MAKNIB(1, 3), /* 0x22: MBOX_GET_RETRY_COUNT */
1384 1.10 mjacob MAKNIB(1, 2), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
1385 1.10 mjacob MAKNIB(1, 2), /* 0x24: MBOX_GET_CLOCK_RATE */
1386 1.10 mjacob MAKNIB(1, 2), /* 0x25: MBOX_GET_ACT_NEG_STATE */
1387 1.10 mjacob MAKNIB(1, 2), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
1388 1.10 mjacob MAKNIB(1, 3), /* 0x27: MBOX_GET_PCI_PARAMS */
1389 1.10 mjacob MAKNIB(2, 4), /* 0x28: MBOX_GET_TARGET_PARAMS */
1390 1.10 mjacob MAKNIB(2, 4), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
1391 1.10 mjacob MAKNIB(0, 0), /* 0x2a: */
1392 1.10 mjacob MAKNIB(0, 0), /* 0x2b: */
1393 1.10 mjacob MAKNIB(0, 0), /* 0x2c: */
1394 1.10 mjacob MAKNIB(0, 0), /* 0x2d: */
1395 1.10 mjacob MAKNIB(0, 0), /* 0x2e: */
1396 1.10 mjacob MAKNIB(0, 0), /* 0x2f: */
1397 1.10 mjacob MAKNIB(2, 2), /* 0x30: MBOX_SET_INIT_SCSI_ID */
1398 1.10 mjacob MAKNIB(2, 2), /* 0x31: MBOX_SET_SELECT_TIMEOUT */
1399 1.10 mjacob MAKNIB(3, 3), /* 0x32: MBOX_SET_RETRY_COUNT */
1400 1.10 mjacob MAKNIB(2, 2), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
1401 1.10 mjacob MAKNIB(2, 2), /* 0x34: MBOX_SET_CLOCK_RATE */
1402 1.10 mjacob MAKNIB(2, 2), /* 0x35: MBOX_SET_ACTIVE_NEG_STATE */
1403 1.10 mjacob MAKNIB(2, 2), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
1404 1.10 mjacob MAKNIB(3, 3), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
1405 1.10 mjacob MAKNIB(4, 4), /* 0x38: MBOX_SET_TARGET_PARAMS */
1406 1.10 mjacob MAKNIB(4, 4), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
1407 1.10 mjacob MAKNIB(0, 0), /* 0x3a: */
1408 1.10 mjacob MAKNIB(0, 0), /* 0x3b: */
1409 1.10 mjacob MAKNIB(0, 0), /* 0x3c: */
1410 1.10 mjacob MAKNIB(0, 0), /* 0x3d: */
1411 1.10 mjacob MAKNIB(0, 0), /* 0x3e: */
1412 1.10 mjacob MAKNIB(0, 0), /* 0x3f: */
1413 1.10 mjacob MAKNIB(1, 2), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
1414 1.10 mjacob MAKNIB(6, 1), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
1415 1.10 mjacob MAKNIB(2, 3), /* 0x42: MBOX_EXEC_BIOS_IOCB */
1416 1.10 mjacob MAKNIB(0, 0), /* 0x43: */
1417 1.10 mjacob MAKNIB(0, 0), /* 0x44: */
1418 1.10 mjacob MAKNIB(0, 0), /* 0x45: */
1419 1.10 mjacob MAKNIB(0, 0), /* 0x46: */
1420 1.10 mjacob MAKNIB(0, 0), /* 0x47: */
1421 1.10 mjacob MAKNIB(0, 0), /* 0x48: */
1422 1.10 mjacob MAKNIB(0, 0), /* 0x49: */
1423 1.10 mjacob MAKNIB(0, 0), /* 0x4a: */
1424 1.10 mjacob MAKNIB(0, 0), /* 0x4b: */
1425 1.10 mjacob MAKNIB(0, 0), /* 0x4c: */
1426 1.10 mjacob MAKNIB(0, 0), /* 0x4d: */
1427 1.10 mjacob MAKNIB(0, 0), /* 0x4e: */
1428 1.10 mjacob MAKNIB(0, 0), /* 0x4f: */
1429 1.10 mjacob MAKNIB(0, 0), /* 0x50: */
1430 1.10 mjacob MAKNIB(0, 0), /* 0x51: */
1431 1.10 mjacob MAKNIB(0, 0), /* 0x52: */
1432 1.10 mjacob MAKNIB(0, 0), /* 0x53: */
1433 1.10 mjacob MAKNIB(8, 0), /* 0x54: MBOX_EXEC_COMMAND_IOCB_A64 */
1434 1.10 mjacob MAKNIB(0, 0), /* 0x55: */
1435 1.10 mjacob MAKNIB(0, 0), /* 0x56: */
1436 1.10 mjacob MAKNIB(0, 0), /* 0x57: */
1437 1.10 mjacob MAKNIB(0, 0), /* 0x58: */
1438 1.10 mjacob MAKNIB(0, 0), /* 0x59: */
1439 1.10 mjacob MAKNIB(0, 0), /* 0x5a: */
1440 1.10 mjacob MAKNIB(0, 0), /* 0x5b: */
1441 1.10 mjacob MAKNIB(0, 0), /* 0x5c: */
1442 1.10 mjacob MAKNIB(0, 0), /* 0x5d: */
1443 1.10 mjacob MAKNIB(0, 0), /* 0x5e: */
1444 1.10 mjacob MAKNIB(0, 0), /* 0x5f: */
1445 1.10 mjacob MAKNIB(8, 6), /* 0x60: MBOX_INIT_FIRMWARE */
1446 1.10 mjacob MAKNIB(0, 0), /* 0x60: MBOX_GET_INIT_CONTROL_BLOCK (FORMAT?) */
1447 1.10 mjacob MAKNIB(2, 1), /* 0x62: MBOX_INIT_LIP */
1448 1.10 mjacob MAKNIB(8, 1), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
1449 1.10 mjacob MAKNIB(8, 1), /* 0x64: MBOX_GET_PORT_DB */
1450 1.10 mjacob MAKNIB(3, 1), /* 0x65: MBOX_CLEAR_ACA */
1451 1.10 mjacob MAKNIB(3, 1), /* 0x66: MBOX_TARGET_RESET */
1452 1.10 mjacob MAKNIB(3, 1), /* 0x67: MBOX_CLEAR_TASK_SET */
1453 1.10 mjacob MAKNIB(3, 1), /* 0x69: MBOX_ABORT_TASK_SET */
1454 1.13 mjacob MAKNIB(1, 2) /* 0x69: MBOX_GET_FW_STATE */
1455 1.1 cgd };
1456 1.1 cgd #define NMBCOM (sizeof (mbpcnt) / sizeof (mbpcnt[0]))
1457 1.1 cgd
1458 1.10 mjacob static void
1459 1.1 cgd isp_mboxcmd(isp, mbp)
1460 1.1 cgd struct ispsoftc *isp;
1461 1.1 cgd mbreg_t *mbp;
1462 1.1 cgd {
1463 1.1 cgd int outparam, inparam;
1464 1.1 cgd int loops;
1465 1.10 mjacob u_int8_t opcode;
1466 1.1 cgd
1467 1.10 mjacob if (mbp->param[0] == ISP2100_SET_PCI_PARAM) {
1468 1.10 mjacob opcode = mbp->param[0] = MBOX_SET_PCI_PARAMETERS;
1469 1.10 mjacob inparam = 4;
1470 1.10 mjacob outparam = 4;
1471 1.10 mjacob goto command_known;
1472 1.10 mjacob } else if (mbp->param[0] > NMBCOM) {
1473 1.23 mjacob PRINTF("%s: bad command %x\n", isp->isp_name, mbp->param[0]);
1474 1.10 mjacob return;
1475 1.1 cgd }
1476 1.1 cgd
1477 1.10 mjacob opcode = mbp->param[0];
1478 1.1 cgd inparam = HINIB(mbpcnt[mbp->param[0]]);
1479 1.1 cgd outparam = LONIB(mbpcnt[mbp->param[0]]);
1480 1.10 mjacob
1481 1.1 cgd if (inparam == 0 && outparam == 0) {
1482 1.23 mjacob PRINTF("%s: no parameters for %x\n", isp->isp_name,
1483 1.1 cgd mbp->param[0]);
1484 1.10 mjacob return;
1485 1.1 cgd }
1486 1.1 cgd
1487 1.10 mjacob
1488 1.10 mjacob command_known:
1489 1.1 cgd /*
1490 1.1 cgd * Make sure we can send some words..
1491 1.1 cgd */
1492 1.1 cgd
1493 1.1 cgd loops = MBOX_DELAY_COUNT;
1494 1.1 cgd while ((ISP_READ(isp, HCCR) & HCCR_HOST_INT) != 0) {
1495 1.23 mjacob SYS_DELAY(100);
1496 1.1 cgd if (--loops < 0) {
1497 1.23 mjacob PRINTF("%s: isp_mboxcmd timeout #1\n", isp->isp_name);
1498 1.10 mjacob return;
1499 1.1 cgd }
1500 1.1 cgd }
1501 1.1 cgd
1502 1.1 cgd /*
1503 1.1 cgd * Write input parameters
1504 1.1 cgd */
1505 1.1 cgd switch (inparam) {
1506 1.10 mjacob case 8: ISP_WRITE(isp, INMAILBOX7, mbp->param[7]); mbp->param[7] = 0;
1507 1.10 mjacob case 7: ISP_WRITE(isp, INMAILBOX6, mbp->param[6]); mbp->param[6] = 0;
1508 1.1 cgd case 6: ISP_WRITE(isp, INMAILBOX5, mbp->param[5]); mbp->param[5] = 0;
1509 1.1 cgd case 5: ISP_WRITE(isp, INMAILBOX4, mbp->param[4]); mbp->param[4] = 0;
1510 1.1 cgd case 4: ISP_WRITE(isp, INMAILBOX3, mbp->param[3]); mbp->param[3] = 0;
1511 1.1 cgd case 3: ISP_WRITE(isp, INMAILBOX2, mbp->param[2]); mbp->param[2] = 0;
1512 1.1 cgd case 2: ISP_WRITE(isp, INMAILBOX1, mbp->param[1]); mbp->param[1] = 0;
1513 1.1 cgd case 1: ISP_WRITE(isp, INMAILBOX0, mbp->param[0]); mbp->param[0] = 0;
1514 1.1 cgd }
1515 1.1 cgd
1516 1.1 cgd /*
1517 1.1 cgd * Clear semaphore on mailbox registers
1518 1.1 cgd */
1519 1.1 cgd ISP_WRITE(isp, BIU_SEMA, 0);
1520 1.1 cgd
1521 1.1 cgd /*
1522 1.1 cgd * Clear RISC int condition.
1523 1.1 cgd */
1524 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
1525 1.1 cgd
1526 1.1 cgd /*
1527 1.1 cgd * Set Host Interrupt condition so that RISC will pick up mailbox regs.
1528 1.1 cgd */
1529 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
1530 1.1 cgd
1531 1.1 cgd /*
1532 1.10 mjacob * Wait until RISC int is set, except 2100
1533 1.1 cgd */
1534 1.10 mjacob if ((isp->isp_type & ISP_HA_FC) == 0) {
1535 1.10 mjacob loops = MBOX_DELAY_COUNT;
1536 1.10 mjacob while ((ISP_READ(isp, BIU_ISR) & BIU_ISR_RISC_INT) == 0) {
1537 1.23 mjacob SYS_DELAY(100);
1538 1.10 mjacob if (--loops < 0) {
1539 1.23 mjacob PRINTF("%s: isp_mboxcmd timeout #2\n",
1540 1.10 mjacob isp->isp_name);
1541 1.10 mjacob return;
1542 1.10 mjacob }
1543 1.1 cgd }
1544 1.1 cgd }
1545 1.1 cgd
1546 1.1 cgd /*
1547 1.1 cgd * Check to make sure that the semaphore has been set.
1548 1.1 cgd */
1549 1.1 cgd loops = MBOX_DELAY_COUNT;
1550 1.1 cgd while ((ISP_READ(isp, BIU_SEMA) & 1) == 0) {
1551 1.23 mjacob SYS_DELAY(100);
1552 1.1 cgd if (--loops < 0) {
1553 1.23 mjacob PRINTF("%s: isp_mboxcmd timeout #3\n", isp->isp_name);
1554 1.10 mjacob return;
1555 1.1 cgd }
1556 1.1 cgd }
1557 1.1 cgd
1558 1.1 cgd /*
1559 1.1 cgd * Make sure that the MBOX_BUSY has gone away
1560 1.1 cgd */
1561 1.1 cgd loops = MBOX_DELAY_COUNT;
1562 1.1 cgd while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
1563 1.23 mjacob SYS_DELAY(100);
1564 1.1 cgd if (--loops < 0) {
1565 1.23 mjacob PRINTF("%s: isp_mboxcmd timeout #4\n", isp->isp_name);
1566 1.10 mjacob return;
1567 1.1 cgd }
1568 1.1 cgd }
1569 1.1 cgd
1570 1.1 cgd
1571 1.1 cgd /*
1572 1.1 cgd * Pick up output parameters.
1573 1.1 cgd */
1574 1.1 cgd switch (outparam) {
1575 1.10 mjacob case 8: mbp->param[7] = ISP_READ(isp, OUTMAILBOX7);
1576 1.10 mjacob case 7: mbp->param[6] = ISP_READ(isp, OUTMAILBOX6);
1577 1.1 cgd case 6: mbp->param[5] = ISP_READ(isp, OUTMAILBOX5);
1578 1.1 cgd case 5: mbp->param[4] = ISP_READ(isp, OUTMAILBOX4);
1579 1.1 cgd case 4: mbp->param[3] = ISP_READ(isp, OUTMAILBOX3);
1580 1.1 cgd case 3: mbp->param[2] = ISP_READ(isp, OUTMAILBOX2);
1581 1.1 cgd case 2: mbp->param[1] = ISP_READ(isp, OUTMAILBOX1);
1582 1.1 cgd case 1: mbp->param[0] = ISP_READ(isp, OUTMAILBOX0);
1583 1.1 cgd }
1584 1.1 cgd
1585 1.1 cgd /*
1586 1.1 cgd * Clear RISC int.
1587 1.1 cgd */
1588 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
1589 1.1 cgd
1590 1.1 cgd /*
1591 1.1 cgd * Release semaphore on mailbox registers
1592 1.1 cgd */
1593 1.1 cgd ISP_WRITE(isp, BIU_SEMA, 0);
1594 1.10 mjacob
1595 1.10 mjacob /*
1596 1.10 mjacob * Just to be chatty here...
1597 1.10 mjacob */
1598 1.10 mjacob switch(mbp->param[0]) {
1599 1.10 mjacob case MBOX_COMMAND_COMPLETE:
1600 1.10 mjacob break;
1601 1.10 mjacob case MBOX_INVALID_COMMAND:
1602 1.10 mjacob /*
1603 1.10 mjacob * GET_CLOCK_RATE can fail a lot
1604 1.10 mjacob * So can a couple of other commands.
1605 1.10 mjacob */
1606 1.20 mjacob if (isp->isp_dblev > 2 && opcode != MBOX_GET_CLOCK_RATE) {
1607 1.23 mjacob PRINTF("%s: mbox cmd %x failed with INVALID_COMMAND\n",
1608 1.10 mjacob isp->isp_name, opcode);
1609 1.10 mjacob }
1610 1.10 mjacob break;
1611 1.10 mjacob case MBOX_HOST_INTERFACE_ERROR:
1612 1.23 mjacob PRINTF("%s: mbox cmd %x failed with HOST_INTERFACE_ERROR\n",
1613 1.10 mjacob isp->isp_name, opcode);
1614 1.10 mjacob break;
1615 1.10 mjacob case MBOX_TEST_FAILED:
1616 1.23 mjacob PRINTF("%s: mbox cmd %x failed with TEST_FAILED\n",
1617 1.10 mjacob isp->isp_name, opcode);
1618 1.10 mjacob break;
1619 1.10 mjacob case MBOX_COMMAND_ERROR:
1620 1.23 mjacob PRINTF("%s: mbox cmd %x failed with COMMAND_ERROR\n",
1621 1.10 mjacob isp->isp_name, opcode);
1622 1.10 mjacob break;
1623 1.10 mjacob case MBOX_COMMAND_PARAM_ERROR:
1624 1.23 mjacob PRINTF("%s: mbox cmd %x failed with COMMAND_PARAM_ERROR\n",
1625 1.10 mjacob isp->isp_name, opcode);
1626 1.10 mjacob break;
1627 1.10 mjacob
1628 1.10 mjacob case ASYNC_LIP_OCCURRED:
1629 1.10 mjacob break;
1630 1.10 mjacob
1631 1.10 mjacob default:
1632 1.10 mjacob /*
1633 1.10 mjacob * The expected return of EXEC_FIRMWARE is zero.
1634 1.10 mjacob */
1635 1.10 mjacob if ((opcode == MBOX_EXEC_FIRMWARE && mbp->param[0] != 0) ||
1636 1.10 mjacob (opcode != MBOX_EXEC_FIRMWARE)) {
1637 1.23 mjacob PRINTF("%s: mbox cmd %x failed with error %x\n",
1638 1.10 mjacob isp->isp_name, opcode, mbp->param[0]);
1639 1.10 mjacob }
1640 1.10 mjacob break;
1641 1.10 mjacob }
1642 1.4 mjacob }
1643 1.4 mjacob
1644 1.23 mjacob void
1645 1.23 mjacob isp_lostcmd(struct ispsoftc *isp, ISP_SCSI_XFER_T *xs)
1646 1.4 mjacob {
1647 1.4 mjacob mbreg_t mbs;
1648 1.10 mjacob
1649 1.4 mjacob mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
1650 1.10 mjacob isp_mboxcmd(isp, &mbs);
1651 1.4 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1652 1.10 mjacob isp_dumpregs(isp, "couldn't GET FIRMWARE STATUS");
1653 1.4 mjacob return;
1654 1.4 mjacob }
1655 1.10 mjacob if (mbs.param[1]) {
1656 1.23 mjacob PRINTF("%s: %d commands on completion queue\n",
1657 1.10 mjacob isp->isp_name, mbs.param[1]);
1658 1.10 mjacob }
1659 1.23 mjacob if (XS_NULL(xs))
1660 1.4 mjacob return;
1661 1.4 mjacob
1662 1.4 mjacob mbs.param[0] = MBOX_GET_DEV_QUEUE_STATUS;
1663 1.23 mjacob mbs.param[1] = XS_TGT(xs) << 8 | XS_LUN(xs);
1664 1.10 mjacob isp_mboxcmd(isp, &mbs);
1665 1.4 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1666 1.10 mjacob isp_dumpregs(isp, "couldn't GET DEVICE QUEUE STATUS");
1667 1.10 mjacob return;
1668 1.10 mjacob }
1669 1.23 mjacob PRINTF("%s: lost command for target %d lun %d, %d active of %d, "
1670 1.23 mjacob "Queue State: %x\n", isp->isp_name, XS_TGT(xs),
1671 1.23 mjacob XS_LUN(xs), mbs.param[2], mbs.param[3], mbs.param[1]);
1672 1.10 mjacob
1673 1.10 mjacob isp_dumpregs(isp, "lost command");
1674 1.10 mjacob /*
1675 1.10 mjacob * XXX: Need to try and do something to recover.
1676 1.10 mjacob */
1677 1.10 mjacob }
1678 1.10 mjacob
1679 1.10 mjacob static void
1680 1.10 mjacob isp_dumpregs(struct ispsoftc *isp, const char *msg)
1681 1.10 mjacob {
1682 1.23 mjacob PRINTF("%s: %s\n", isp->isp_name, msg);
1683 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI)
1684 1.23 mjacob PRINTF(" biu_conf1=%x", ISP_READ(isp, BIU_CONF1));
1685 1.10 mjacob else
1686 1.23 mjacob PRINTF(" biu_csr=%x", ISP_READ(isp, BIU2100_CSR));
1687 1.23 mjacob PRINTF(" biu_icr=%x biu_isr=%x biu_sema=%x ", ISP_READ(isp, BIU_ICR),
1688 1.10 mjacob ISP_READ(isp, BIU_ISR), ISP_READ(isp, BIU_SEMA));
1689 1.23 mjacob PRINTF("risc_hccr=%x\n", ISP_READ(isp, HCCR));
1690 1.10 mjacob
1691 1.10 mjacob if (isp->isp_type & ISP_HA_SCSI) {
1692 1.10 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
1693 1.23 mjacob PRINTF(" cdma_conf=%x cdma_sts=%x cdma_fifostat=%x\n",
1694 1.10 mjacob ISP_READ(isp, CDMA_CONF), ISP_READ(isp, CDMA_STATUS),
1695 1.10 mjacob ISP_READ(isp, CDMA_FIFO_STS));
1696 1.23 mjacob PRINTF(" ddma_conf=%x ddma_sts=%x ddma_fifostat=%x\n",
1697 1.10 mjacob ISP_READ(isp, DDMA_CONF), ISP_READ(isp, DDMA_STATUS),
1698 1.10 mjacob ISP_READ(isp, DDMA_FIFO_STS));
1699 1.23 mjacob PRINTF(" sxp_int=%x sxp_gross=%x sxp(scsi_ctrl)=%x\n",
1700 1.10 mjacob ISP_READ(isp, SXP_INTERRUPT),
1701 1.10 mjacob ISP_READ(isp, SXP_GROSS_ERR),
1702 1.10 mjacob ISP_READ(isp, SXP_PINS_CONTROL));
1703 1.10 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
1704 1.10 mjacob }
1705 1.10 mjacob ISP_DUMPREGS(isp);
1706 1.10 mjacob }
1707 1.10 mjacob
1708 1.10 mjacob static void
1709 1.23 mjacob isp_dumpxflist(struct ispsoftc *isp)
1710 1.23 mjacob {
1711 1.23 mjacob volatile ISP_SCSI_XFER_T *xs;
1712 1.23 mjacob int i, hdp;
1713 1.23 mjacob
1714 1.23 mjacob for (hdp = i = 0; i < RQUEST_QUEUE_LEN; i++) {
1715 1.23 mjacob xs = isp->isp_xflist[i];
1716 1.23 mjacob if (xs == NULL) {
1717 1.23 mjacob continue;
1718 1.23 mjacob }
1719 1.23 mjacob if (hdp == 0) {
1720 1.23 mjacob PRINTF("%s: active requests\n", isp->isp_name);
1721 1.23 mjacob hdp++;
1722 1.23 mjacob }
1723 1.23 mjacob PRINTF(" Active Handle %d: tgt %d lun %d dlen %d\n",
1724 1.23 mjacob i+1, XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs));
1725 1.23 mjacob }
1726 1.23 mjacob }
1727 1.23 mjacob
1728 1.23 mjacob static void
1729 1.10 mjacob isp_fw_state(struct ispsoftc *isp)
1730 1.10 mjacob {
1731 1.10 mjacob mbreg_t mbs;
1732 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
1733 1.10 mjacob int once = 0;
1734 1.10 mjacob fcparam *fcp = isp->isp_param;
1735 1.10 mjacob again:
1736 1.10 mjacob mbs.param[0] = MBOX_GET_FW_STATE;
1737 1.10 mjacob isp_mboxcmd(isp, &mbs);
1738 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1739 1.10 mjacob if (mbs.param[0] == ASYNC_LIP_OCCURRED) {
1740 1.10 mjacob if (!once++) {
1741 1.10 mjacob goto again;
1742 1.10 mjacob }
1743 1.10 mjacob }
1744 1.10 mjacob isp_dumpregs(isp, "GET FIRMWARE STATE failed");
1745 1.10 mjacob return;
1746 1.10 mjacob }
1747 1.10 mjacob fcp->isp_fwstate = mbs.param[1];
1748 1.10 mjacob }
1749 1.10 mjacob }
1750 1.10 mjacob
1751 1.10 mjacob static void
1752 1.10 mjacob isp_setdparm(struct ispsoftc *isp)
1753 1.10 mjacob {
1754 1.10 mjacob int i;
1755 1.10 mjacob mbreg_t mbs;
1756 1.10 mjacob sdparam *sdp;
1757 1.10 mjacob
1758 1.10 mjacob isp->isp_fwrev = 0;
1759 1.10 mjacob if (isp->isp_type & ISP_HA_FC) {
1760 1.10 mjacob /*
1761 1.10 mjacob * ROM in 2100 doesn't appear to support ABOUT_FIRMWARE
1762 1.10 mjacob */
1763 1.4 mjacob return;
1764 1.4 mjacob }
1765 1.10 mjacob
1766 1.10 mjacob mbs.param[0] = MBOX_ABOUT_FIRMWARE;
1767 1.10 mjacob isp_mboxcmd(isp, &mbs);
1768 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1769 1.20 mjacob IDPRINTF(3, ("1st ABOUT FIRMWARE command failed"));
1770 1.10 mjacob } else {
1771 1.10 mjacob isp->isp_fwrev =
1772 1.10 mjacob (((u_int16_t) mbs.param[1]) << 10) + mbs.param[2];
1773 1.10 mjacob }
1774 1.10 mjacob
1775 1.10 mjacob
1776 1.10 mjacob sdp = (sdparam *) isp->isp_param;
1777 1.10 mjacob /*
1778 1.10 mjacob * Try and get old clock rate out before we hit the
1779 1.10 mjacob * chip over the head- but if and only if we don't
1780 1.10 mjacob * know our desired clock rate.
1781 1.10 mjacob */
1782 1.10 mjacob if (isp->isp_mdvec->dv_clock == 0) {
1783 1.10 mjacob mbs.param[0] = MBOX_GET_CLOCK_RATE;
1784 1.10 mjacob isp_mboxcmd(isp, &mbs);
1785 1.10 mjacob if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1786 1.10 mjacob sdp->isp_clock = mbs.param[1];
1787 1.23 mjacob PRINTF("%s: using board clock 0x%x\n",
1788 1.10 mjacob isp->isp_name, sdp->isp_clock);
1789 1.10 mjacob }
1790 1.10 mjacob } else {
1791 1.10 mjacob sdp->isp_clock = isp->isp_mdvec->dv_clock;
1792 1.10 mjacob }
1793 1.10 mjacob
1794 1.10 mjacob mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
1795 1.10 mjacob isp_mboxcmd(isp, &mbs);
1796 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1797 1.23 mjacob IDPRINTF(2, ("could not GET ACT NEG STATE\n"));
1798 1.10 mjacob sdp->isp_req_ack_active_neg = 1;
1799 1.10 mjacob sdp->isp_data_line_active_neg = 1;
1800 1.10 mjacob } else {
1801 1.10 mjacob sdp->isp_req_ack_active_neg = (mbs.param[1] >> 4) & 0x1;
1802 1.10 mjacob sdp->isp_data_line_active_neg = (mbs.param[1] >> 5) & 0x1;
1803 1.10 mjacob }
1804 1.10 mjacob for (i = 0; i < MAX_TARGETS; i++) {
1805 1.10 mjacob mbs.param[0] = MBOX_GET_TARGET_PARAMS;
1806 1.10 mjacob mbs.param[1] = i << 8;
1807 1.10 mjacob isp_mboxcmd(isp, &mbs);
1808 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1809 1.23 mjacob IDPRINTF(2, ("cannot get params for target %d\n", i));
1810 1.10 mjacob sdp->isp_devparam[i].sync_period =
1811 1.10 mjacob ISP_10M_SYNCPARMS & 0xff;
1812 1.10 mjacob sdp->isp_devparam[i].sync_offset =
1813 1.10 mjacob ISP_10M_SYNCPARMS >> 8;
1814 1.10 mjacob sdp->isp_devparam[i].dev_flags = DPARM_DEFAULT;
1815 1.10 mjacob } else {
1816 1.23 mjacob IDPRINTF(3, ("\%s: target %d - flags 0x%x, sync %x\n",
1817 1.23 mjacob isp->isp_name, i, mbs.param[2], mbs.param[3]));
1818 1.10 mjacob sdp->isp_devparam[i].dev_flags = mbs.param[2] >> 8;
1819 1.10 mjacob /*
1820 1.10 mjacob * The maximum period we can really see
1821 1.10 mjacob * here is 100 (decimal), or 400 ns.
1822 1.10 mjacob * For some unknown reason we sometimes
1823 1.10 mjacob * get back wildass numbers from the
1824 1.10 mjacob * boot device's paramaters.
1825 1.10 mjacob */
1826 1.10 mjacob if ((mbs.param[3] & 0xff) <= 0x64) {
1827 1.10 mjacob sdp->isp_devparam[i].sync_period =
1828 1.10 mjacob mbs.param[3] & 0xff;
1829 1.10 mjacob sdp->isp_devparam[i].sync_offset =
1830 1.10 mjacob mbs.param[3] >> 8;
1831 1.10 mjacob }
1832 1.10 mjacob }
1833 1.10 mjacob }
1834 1.10 mjacob
1835 1.10 mjacob /*
1836 1.10 mjacob * Set Default Host Adapter Parameters
1837 1.10 mjacob * XXX: Should try and get them out of NVRAM
1838 1.10 mjacob */
1839 1.10 mjacob sdp->isp_adapter_enabled = 1;
1840 1.10 mjacob sdp->isp_cmd_dma_burst_enable = 1;
1841 1.10 mjacob sdp->isp_data_dma_burst_enabl = 1;
1842 1.10 mjacob sdp->isp_fifo_threshold = 2;
1843 1.10 mjacob sdp->isp_initiator_id = 7;
1844 1.10 mjacob sdp->isp_async_data_setup = 6;
1845 1.10 mjacob sdp->isp_selection_timeout = 250;
1846 1.23 mjacob sdp->isp_max_queue_depth = 128;
1847 1.10 mjacob sdp->isp_tag_aging = 8;
1848 1.10 mjacob sdp->isp_bus_reset_delay = 3;
1849 1.10 mjacob sdp->isp_retry_count = 0;
1850 1.10 mjacob sdp->isp_retry_delay = 1;
1851 1.10 mjacob
1852 1.10 mjacob for (i = 0; i < MAX_TARGETS; i++) {
1853 1.10 mjacob sdp->isp_devparam[i].exc_throttle = 16;
1854 1.10 mjacob sdp->isp_devparam[i].dev_enable = 1;
1855 1.10 mjacob }
1856 1.10 mjacob }
1857 1.10 mjacob
1858 1.10 mjacob static void
1859 1.10 mjacob isp_phoenix(struct ispsoftc *isp)
1860 1.10 mjacob {
1861 1.23 mjacob ISP_SCSI_XFER_T *tlist[RQUEST_QUEUE_LEN], *xs;
1862 1.10 mjacob int i;
1863 1.10 mjacob
1864 1.23 mjacob for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
1865 1.23 mjacob tlist[i] = (ISP_SCSI_XFER_T *) isp->isp_xflist[i];
1866 1.10 mjacob }
1867 1.10 mjacob isp_reset(isp);
1868 1.10 mjacob isp_init(isp);
1869 1.10 mjacob isp->isp_state = ISP_RUNSTATE;
1870 1.10 mjacob
1871 1.23 mjacob for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
1872 1.10 mjacob xs = tlist[i];
1873 1.23 mjacob if (XS_NULL(xs))
1874 1.10 mjacob continue;
1875 1.23 mjacob isp->isp_nactive--;
1876 1.23 mjacob if (isp->isp_nactive < 0)
1877 1.23 mjacob isp->isp_nactive = 0;
1878 1.23 mjacob XS_RESID(xs) = XS_XFRLEN(xs);
1879 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
1880 1.23 mjacob XS_CMD_DONE(xs);
1881 1.10 mjacob }
1882 1.10 mjacob }
1883 1.10 mjacob
1884 1.23 mjacob void
1885 1.10 mjacob isp_watch(void *arg)
1886 1.10 mjacob {
1887 1.23 mjacob int i;
1888 1.10 mjacob struct ispsoftc *isp = arg;
1889 1.23 mjacob ISP_SCSI_XFER_T *xs;
1890 1.23 mjacob ISP_LOCKVAL_DECL;
1891 1.10 mjacob
1892 1.10 mjacob /*
1893 1.23 mjacob * Look for completely dead commands (but not polled ones).
1894 1.10 mjacob */
1895 1.23 mjacob ISP_ILOCK(isp);
1896 1.23 mjacob for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
1897 1.23 mjacob if ((xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[i]) == NULL) {
1898 1.10 mjacob continue;
1899 1.10 mjacob }
1900 1.23 mjacob if (XS_TIME(xs) == 0) {
1901 1.10 mjacob continue;
1902 1.23 mjacob }
1903 1.23 mjacob XS_TIME(xs) -= (WATCH_INTERVAL * 1000);
1904 1.23 mjacob /*
1905 1.23 mjacob * Avoid later thinking that this
1906 1.23 mjacob * transaction is not being timed.
1907 1.23 mjacob * Then give ourselves to watchdog
1908 1.23 mjacob * periods of grace.
1909 1.23 mjacob */
1910 1.23 mjacob if (XS_TIME(xs) == 0)
1911 1.23 mjacob XS_TIME(xs) = 1;
1912 1.23 mjacob else if (XS_TIME(xs) > -(2 * WATCH_INTERVAL * 1000)) {
1913 1.10 mjacob continue;
1914 1.10 mjacob }
1915 1.23 mjacob if (isp_control(isp, ISPCTL_ABORT_CMD, xs)) {
1916 1.23 mjacob PRINTF("%s: isp_watch failed to abort command\n",
1917 1.23 mjacob isp->isp_name);
1918 1.23 mjacob isp_phoenix(isp);
1919 1.23 mjacob break;
1920 1.10 mjacob }
1921 1.10 mjacob }
1922 1.23 mjacob ISP_IUNLOCK(isp);
1923 1.23 mjacob RESTART_WATCHDOG(isp_watch, isp);
1924 1.15 mjacob }
1925 1.15 mjacob
1926 1.15 mjacob static void
1927 1.15 mjacob isp_prtstst(ispstatusreq_t *sp)
1928 1.15 mjacob {
1929 1.23 mjacob PRINTF("states->");
1930 1.15 mjacob if (sp->req_state_flags & RQSF_GOT_BUS)
1931 1.23 mjacob PRINTF("GOT_BUS ");
1932 1.15 mjacob if (sp->req_state_flags & RQSF_GOT_TARGET)
1933 1.23 mjacob PRINTF("GOT_TGT ");
1934 1.15 mjacob if (sp->req_state_flags & RQSF_SENT_CDB)
1935 1.23 mjacob PRINTF("SENT_CDB ");
1936 1.15 mjacob if (sp->req_state_flags & RQSF_XFRD_DATA)
1937 1.23 mjacob PRINTF("XFRD_DATA ");
1938 1.15 mjacob if (sp->req_state_flags & RQSF_GOT_STATUS)
1939 1.23 mjacob PRINTF("GOT_STS ");
1940 1.15 mjacob if (sp->req_state_flags & RQSF_GOT_SENSE)
1941 1.23 mjacob PRINTF("GOT_SNS ");
1942 1.15 mjacob if (sp->req_state_flags & RQSF_XFER_COMPLETE)
1943 1.23 mjacob PRINTF("XFR_CMPLT ");
1944 1.23 mjacob PRINTF("\n");
1945 1.23 mjacob PRINTF("status->");
1946 1.15 mjacob if (sp->req_status_flags & RQSTF_DISCONNECT)
1947 1.23 mjacob PRINTF("Disconnect ");
1948 1.15 mjacob if (sp->req_status_flags & RQSTF_SYNCHRONOUS)
1949 1.23 mjacob PRINTF("Sync_xfr ");
1950 1.15 mjacob if (sp->req_status_flags & RQSTF_PARITY_ERROR)
1951 1.23 mjacob PRINTF("Parity ");
1952 1.15 mjacob if (sp->req_status_flags & RQSTF_BUS_RESET)
1953 1.23 mjacob PRINTF("Bus_Reset ");
1954 1.15 mjacob if (sp->req_status_flags & RQSTF_DEVICE_RESET)
1955 1.23 mjacob PRINTF("Device_Reset ");
1956 1.15 mjacob if (sp->req_status_flags & RQSTF_ABORTED)
1957 1.23 mjacob PRINTF("Aborted ");
1958 1.15 mjacob if (sp->req_status_flags & RQSTF_TIMEOUT)
1959 1.23 mjacob PRINTF("Timeout ");
1960 1.15 mjacob if (sp->req_status_flags & RQSTF_NEGOTIATION)
1961 1.23 mjacob PRINTF("Negotiation ");
1962 1.23 mjacob PRINTF("\n");
1963 1.1 cgd }
1964