isp.c revision 1.62 1 1.62 mjacob /* $NetBSD: isp.c,v 1.62 2000/10/16 05:15:05 mjacob Exp $ */
2 1.60 mjacob /*
3 1.60 mjacob * This driver, which is contained in NetBSD in the files:
4 1.60 mjacob *
5 1.60 mjacob * sys/dev/ic/isp.c
6 1.60 mjacob * sys/dev/ic/ic/isp.c
7 1.60 mjacob * sys/dev/ic/ic/isp_inline.h
8 1.60 mjacob * sys/dev/ic/ic/isp_netbsd.c
9 1.60 mjacob * sys/dev/ic/ic/isp_netbsd.h
10 1.60 mjacob * sys/dev/ic/ic/isp_target.c
11 1.60 mjacob * sys/dev/ic/ic/isp_target.h
12 1.60 mjacob * sys/dev/ic/ic/isp_tpublic.h
13 1.60 mjacob * sys/dev/ic/ic/ispmbox.h
14 1.60 mjacob * sys/dev/ic/ic/ispreg.h
15 1.60 mjacob * sys/dev/ic/ic/ispvar.h
16 1.60 mjacob * sys/microcode/isp/asm_sbus.h
17 1.60 mjacob * sys/microcode/isp/asm_1040.h
18 1.60 mjacob * sys/microcode/isp/asm_1080.h
19 1.60 mjacob * sys/microcode/isp/asm_12160.h
20 1.60 mjacob * sys/microcode/isp/asm_2100.h
21 1.60 mjacob * sys/microcode/isp/asm_2200.h
22 1.60 mjacob * sys/pci/isp_pci.c
23 1.60 mjacob * sys/sbus/isp_sbus.c
24 1.60 mjacob *
25 1.60 mjacob * Is being actively maintained by Matthew Jacob (mjacob (at) netbsd.org).
26 1.60 mjacob * This driver also is shared source with FreeBSD, OpenBSD, Linux, Solaris,
27 1.60 mjacob * Linux versions. This tends to be an interesting maintenance problem.
28 1.60 mjacob *
29 1.60 mjacob * Please coordinate with Matthew Jacob on changes you wish to make here.
30 1.60 mjacob */
31 1.1 cgd /*
32 1.54 mjacob * Machine and OS Independent (well, as best as possible)
33 1.54 mjacob * code for the Qlogic ISP SCSI adapters.
34 1.54 mjacob *
35 1.54 mjacob * Copyright (c) 1997, 1998, 1999 by Matthew Jacob
36 1.54 mjacob * NASA/Ames Research Center
37 1.1 cgd * All rights reserved.
38 1.1 cgd *
39 1.1 cgd * Redistribution and use in source and binary forms, with or without
40 1.1 cgd * modification, are permitted provided that the following conditions
41 1.1 cgd * are met:
42 1.1 cgd * 1. Redistributions of source code must retain the above copyright
43 1.54 mjacob * notice immediately at the beginning of the file, without modification,
44 1.54 mjacob * this list of conditions, and the following disclaimer.
45 1.62 mjacob * 2. The name of the author may not be used to endorse or promote products
46 1.54 mjacob * derived from this software without specific prior written permission.
47 1.1 cgd *
48 1.54 mjacob * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
49 1.54 mjacob * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 1.54 mjacob * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 1.54 mjacob * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
52 1.54 mjacob * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 1.54 mjacob * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 1.54 mjacob * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 1.54 mjacob * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 1.54 mjacob * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 1.54 mjacob * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 1.54 mjacob * SUCH DAMAGE.
59 1.1 cgd */
60 1.2 cgd
61 1.1 cgd /*
62 1.1 cgd * Inspiration and ideas about this driver are from Erik Moe's Linux driver
63 1.23 mjacob * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
64 1.23 mjacob * ideas dredged from the Solaris driver.
65 1.1 cgd */
66 1.1 cgd
67 1.23 mjacob /*
68 1.23 mjacob * Include header file appropriate for platform we're building on.
69 1.23 mjacob */
70 1.1 cgd
71 1.23 mjacob #ifdef __NetBSD__
72 1.23 mjacob #include <dev/ic/isp_netbsd.h>
73 1.23 mjacob #endif
74 1.23 mjacob #ifdef __FreeBSD__
75 1.23 mjacob #include <dev/isp/isp_freebsd.h>
76 1.23 mjacob #endif
77 1.33 mjacob #ifdef __OpenBSD__
78 1.33 mjacob #include <dev/ic/isp_openbsd.h>
79 1.33 mjacob #endif
80 1.23 mjacob #ifdef __linux__
81 1.29 mjacob #include "isp_linux.h"
82 1.23 mjacob #endif
83 1.57 mjacob #ifdef __svr4__
84 1.57 mjacob #include "isp_solaris.h"
85 1.57 mjacob #endif
86 1.1 cgd
87 1.23 mjacob /*
88 1.23 mjacob * General defines
89 1.23 mjacob */
90 1.1 cgd
91 1.23 mjacob #define MBOX_DELAY_COUNT 1000000 / 100
92 1.1 cgd
93 1.23 mjacob /*
94 1.27 mjacob * Local static data
95 1.27 mjacob */
96 1.57 mjacob static char *warnlun =
97 1.57 mjacob "WARNING- cannot determine Expanded LUN capability- limiting to one LUN";
98 1.57 mjacob static char *portshift =
99 1.57 mjacob "Target %d Loop ID 0x%x (Port 0x%x) => Loop 0x%x (Port 0x%x)";
100 1.57 mjacob static char *portdup =
101 1.57 mjacob "Target %d duplicates Target %d- killing off both";
102 1.57 mjacob static char *retained =
103 1.57 mjacob "Retaining Loop ID 0x%x for Target %d (Port 0x%x)";
104 1.57 mjacob #ifdef ISP2100_FABRIC
105 1.57 mjacob static char *lretained =
106 1.57 mjacob "Retained login of Target %d (Loop ID 0x%x) Port 0x%x";
107 1.57 mjacob static char *plogout =
108 1.57 mjacob "Logging out Target %d at Loop ID 0x%x (Port 0x%x)";
109 1.57 mjacob static char *plogierr =
110 1.57 mjacob "Command Error in PLOGI for Port 0x%x (0x%x)";
111 1.57 mjacob static char *nopdb =
112 1.57 mjacob "Could not get PDB for Device @ Port 0x%x";
113 1.57 mjacob static char *pdbmfail1 =
114 1.57 mjacob "PDB Loop ID info for Device @ Port 0x%x does not match up (0x%x)";
115 1.57 mjacob static char *pdbmfail2 =
116 1.57 mjacob "PDB Port info for Device @ Port 0x%x does not match up (0x%x)";
117 1.57 mjacob static char *ldumped =
118 1.57 mjacob "Target %d (Loop ID 0x%x) Port 0x%x dumped after login info mismatch";
119 1.57 mjacob #endif
120 1.57 mjacob static char *notresp =
121 1.57 mjacob "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d)";
122 1.57 mjacob static char *xact1 =
123 1.57 mjacob "HBA attempted queued transaction with disconnect not set for %d.%d.%d";
124 1.57 mjacob static char *xact2 =
125 1.57 mjacob "HBA attempted queued transaction to target routine %d on target %d bus %d";
126 1.57 mjacob static char *xact3 =
127 1.57 mjacob "HBA attempted queued cmd for %d.%d.%d when queueing disabled";
128 1.57 mjacob static char *pskip =
129 1.57 mjacob "SCSI phase skipped for target %d.%d.%d";
130 1.57 mjacob static char *topology =
131 1.57 mjacob "Loop ID %d, AL_PA 0x%x, Port ID 0x%x, Loop State 0x%x, Topology '%s'";
132 1.57 mjacob static char *finmsg =
133 1.57 mjacob "(%d.%d.%d): FIN dl%d resid%d STS 0x%x SKEY %c XS_ERR=0x%x";
134 1.27 mjacob /*
135 1.25 mjacob * Local function prototypes.
136 1.23 mjacob */
137 1.28 mjacob static int isp_parse_async __P((struct ispsoftc *, int));
138 1.25 mjacob static int isp_handle_other_response
139 1.43 mjacob __P((struct ispsoftc *, ispstatusreq_t *, u_int16_t *));
140 1.23 mjacob static void isp_parse_status
141 1.57 mjacob __P((struct ispsoftc *, ispstatusreq_t *, XS_T *));
142 1.38 mjacob static void isp_fastpost_complete __P((struct ispsoftc *, u_int32_t));
143 1.36 mjacob static void isp_scsi_init __P((struct ispsoftc *));
144 1.36 mjacob static void isp_scsi_channel_init __P((struct ispsoftc *, int));
145 1.10 mjacob static void isp_fibre_init __P((struct ispsoftc *));
146 1.33 mjacob static void isp_mark_getpdb_all __P((struct ispsoftc *));
147 1.33 mjacob static int isp_getpdb __P((struct ispsoftc *, int, isp_pdb_t *));
148 1.37 mjacob static u_int64_t isp_get_portname __P((struct ispsoftc *, int, int));
149 1.34 mjacob static int isp_fclink_test __P((struct ispsoftc *, int));
150 1.57 mjacob static char *isp2100_fw_statename __P((int));
151 1.37 mjacob static int isp_same_lportdb __P((struct lportdb *, struct lportdb *));
152 1.37 mjacob static int isp_pdb_sync __P((struct ispsoftc *, int));
153 1.37 mjacob #ifdef ISP2100_FABRIC
154 1.37 mjacob static int isp_scan_fabric __P((struct ispsoftc *));
155 1.37 mjacob #endif
156 1.10 mjacob static void isp_fw_state __P((struct ispsoftc *));
157 1.57 mjacob static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *, int));
158 1.1 cgd
159 1.36 mjacob static void isp_update __P((struct ispsoftc *));
160 1.36 mjacob static void isp_update_bus __P((struct ispsoftc *, int));
161 1.36 mjacob static void isp_setdfltparm __P((struct ispsoftc *, int));
162 1.25 mjacob static int isp_read_nvram __P((struct ispsoftc *));
163 1.25 mjacob static void isp_rdnvram_word __P((struct ispsoftc *, int, u_int16_t *));
164 1.49 mjacob static void isp_parse_nvram_1020 __P((struct ispsoftc *, u_int8_t *));
165 1.49 mjacob static void isp_parse_nvram_1080 __P((struct ispsoftc *, int, u_int8_t *));
166 1.49 mjacob static void isp_parse_nvram_12160 __P((struct ispsoftc *, int, u_int8_t *));
167 1.49 mjacob static void isp_parse_nvram_2100 __P((struct ispsoftc *, u_int8_t *));
168 1.49 mjacob
169 1.1 cgd /*
170 1.1 cgd * Reset Hardware.
171 1.25 mjacob *
172 1.43 mjacob * Hit the chip over the head, download new f/w if available and set it running.
173 1.25 mjacob *
174 1.24 mjacob * Locking done elsewhere.
175 1.1 cgd */
176 1.1 cgd void
177 1.1 cgd isp_reset(isp)
178 1.1 cgd struct ispsoftc *isp;
179 1.1 cgd {
180 1.1 cgd mbreg_t mbs;
181 1.54 mjacob int loops, i, touched, dodnld = 1;
182 1.10 mjacob char *revname;
183 1.1 cgd
184 1.1 cgd isp->isp_state = ISP_NILSTATE;
185 1.4 mjacob
186 1.57 mjacob
187 1.4 mjacob /*
188 1.25 mjacob * Basic types (SCSI, FibreChannel and PCI or SBus)
189 1.25 mjacob * have been set in the MD code. We figure out more
190 1.25 mjacob * here.
191 1.57 mjacob *
192 1.32 mjacob * After we've fired this chip up, zero out the conf1 register
193 1.57 mjacob * for SCSI adapters and do other settings for the 2100.
194 1.32 mjacob */
195 1.32 mjacob
196 1.32 mjacob /*
197 1.31 mjacob * Get the current running firmware revision out of the
198 1.31 mjacob * chip before we hit it over the head (if this is our
199 1.31 mjacob * first time through). Note that we store this as the
200 1.31 mjacob * 'ROM' firmware revision- which it may not be. In any
201 1.31 mjacob * case, we don't really use this yet, but we may in
202 1.31 mjacob * the future.
203 1.31 mjacob */
204 1.54 mjacob if ((touched = isp->isp_touched) == 0) {
205 1.31 mjacob /*
206 1.57 mjacob * First see whether or not we're sitting in the ISP PROM.
207 1.57 mjacob * If we've just been reset, we'll have the string "ISP "
208 1.57 mjacob * spread through outgoing mailbox registers 1-3.
209 1.57 mjacob */
210 1.57 mjacob if (ISP_READ(isp, OUTMAILBOX1) != 0x4953 ||
211 1.57 mjacob ISP_READ(isp, OUTMAILBOX2) != 0x5020 ||
212 1.57 mjacob ISP_READ(isp, OUTMAILBOX3) != 0x2020) {
213 1.57 mjacob /*
214 1.57 mjacob * Just in case it was paused...
215 1.57 mjacob */
216 1.57 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
217 1.57 mjacob mbs.param[0] = MBOX_ABOUT_FIRMWARE;
218 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGNONE);
219 1.57 mjacob /*
220 1.57 mjacob * This *shouldn't* fail.....
221 1.57 mjacob */
222 1.57 mjacob if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
223 1.57 mjacob isp->isp_romfw_rev[0] = mbs.param[1];
224 1.57 mjacob isp->isp_romfw_rev[1] = mbs.param[2];
225 1.57 mjacob isp->isp_romfw_rev[2] = mbs.param[3];
226 1.57 mjacob }
227 1.30 mjacob }
228 1.43 mjacob isp->isp_touched = 1;
229 1.30 mjacob }
230 1.30 mjacob
231 1.35 mjacob DISABLE_INTS(isp);
232 1.35 mjacob
233 1.31 mjacob /*
234 1.44 mjacob * Put the board into PAUSE mode (so we can read the SXP registers).
235 1.31 mjacob */
236 1.31 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
237 1.31 mjacob
238 1.37 mjacob if (IS_FC(isp)) {
239 1.37 mjacob revname = "2X00";
240 1.37 mjacob switch (isp->isp_type) {
241 1.37 mjacob case ISP_HA_FC_2100:
242 1.37 mjacob revname[1] = '1';
243 1.37 mjacob break;
244 1.37 mjacob case ISP_HA_FC_2200:
245 1.37 mjacob revname[1] = '2';
246 1.37 mjacob break;
247 1.37 mjacob default:
248 1.37 mjacob break;
249 1.37 mjacob }
250 1.44 mjacob } else if (IS_1240(isp)) {
251 1.44 mjacob sdparam *sdp = isp->isp_param;
252 1.44 mjacob revname = "1240";
253 1.36 mjacob isp->isp_clock = 60;
254 1.44 mjacob sdp->isp_ultramode = 1;
255 1.44 mjacob sdp++;
256 1.44 mjacob sdp->isp_ultramode = 1;
257 1.44 mjacob /*
258 1.44 mjacob * XXX: Should probably do some bus sensing.
259 1.44 mjacob */
260 1.44 mjacob } else if (IS_ULTRA2(isp)) {
261 1.57 mjacob static char *m = "bus %d is in %s Mode";
262 1.34 mjacob u_int16_t l;
263 1.33 mjacob sdparam *sdp = isp->isp_param;
264 1.44 mjacob
265 1.44 mjacob isp->isp_clock = 100;
266 1.44 mjacob
267 1.49 mjacob if (IS_1280(isp))
268 1.49 mjacob revname = "1280";
269 1.49 mjacob else if (IS_1080(isp))
270 1.49 mjacob revname = "1080";
271 1.49 mjacob else if (IS_12160(isp))
272 1.49 mjacob revname = "12160";
273 1.49 mjacob else
274 1.49 mjacob revname = "<UNKLVD>";
275 1.49 mjacob
276 1.34 mjacob l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
277 1.34 mjacob switch (l) {
278 1.34 mjacob case ISP1080_LVD_MODE:
279 1.34 mjacob sdp->isp_lvdmode = 1;
280 1.57 mjacob isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
281 1.34 mjacob break;
282 1.34 mjacob case ISP1080_HVD_MODE:
283 1.34 mjacob sdp->isp_diffmode = 1;
284 1.57 mjacob isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
285 1.34 mjacob break;
286 1.34 mjacob case ISP1080_SE_MODE:
287 1.34 mjacob sdp->isp_ultramode = 1;
288 1.57 mjacob isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
289 1.34 mjacob break;
290 1.34 mjacob default:
291 1.57 mjacob isp_prt(isp, ISP_LOGERR,
292 1.57 mjacob "unknown mode on bus %d (0x%x)", 0, l);
293 1.34 mjacob break;
294 1.34 mjacob }
295 1.44 mjacob
296 1.49 mjacob if (IS_DUALBUS(isp)) {
297 1.44 mjacob sdp++;
298 1.44 mjacob l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
299 1.44 mjacob l &= ISP1080_MODE_MASK;
300 1.44 mjacob switch(l) {
301 1.44 mjacob case ISP1080_LVD_MODE:
302 1.44 mjacob sdp->isp_lvdmode = 1;
303 1.57 mjacob isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
304 1.44 mjacob break;
305 1.44 mjacob case ISP1080_HVD_MODE:
306 1.44 mjacob sdp->isp_diffmode = 1;
307 1.57 mjacob isp_prt(isp, ISP_LOGCONFIG,
308 1.57 mjacob m, 1, "Differential");
309 1.44 mjacob break;
310 1.44 mjacob case ISP1080_SE_MODE:
311 1.44 mjacob sdp->isp_ultramode = 1;
312 1.57 mjacob isp_prt(isp, ISP_LOGCONFIG,
313 1.57 mjacob m, 1, "Single-Ended");
314 1.44 mjacob break;
315 1.44 mjacob default:
316 1.57 mjacob isp_prt(isp, ISP_LOGERR,
317 1.57 mjacob "unknown mode on bus %d (0x%x)", 1, l);
318 1.44 mjacob break;
319 1.44 mjacob }
320 1.44 mjacob }
321 1.10 mjacob } else {
322 1.25 mjacob sdparam *sdp = isp->isp_param;
323 1.30 mjacob i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
324 1.30 mjacob switch (i) {
325 1.10 mjacob default:
326 1.57 mjacob isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
327 1.25 mjacob /* FALLTHROUGH */
328 1.10 mjacob case 1:
329 1.34 mjacob revname = "1020";
330 1.10 mjacob isp->isp_type = ISP_HA_SCSI_1020;
331 1.36 mjacob isp->isp_clock = 40;
332 1.22 mjacob break;
333 1.22 mjacob case 2:
334 1.25 mjacob /*
335 1.25 mjacob * Some 1020A chips are Ultra Capable, but don't
336 1.25 mjacob * run the clock rate up for that unless told to
337 1.25 mjacob * do so by the Ultra Capable bits being set.
338 1.25 mjacob */
339 1.34 mjacob revname = "1020A";
340 1.22 mjacob isp->isp_type = ISP_HA_SCSI_1020A;
341 1.36 mjacob isp->isp_clock = 40;
342 1.10 mjacob break;
343 1.10 mjacob case 3:
344 1.25 mjacob revname = "1040";
345 1.25 mjacob isp->isp_type = ISP_HA_SCSI_1040;
346 1.36 mjacob isp->isp_clock = 60;
347 1.25 mjacob break;
348 1.25 mjacob case 4:
349 1.10 mjacob revname = "1040A";
350 1.10 mjacob isp->isp_type = ISP_HA_SCSI_1040A;
351 1.36 mjacob isp->isp_clock = 60;
352 1.10 mjacob break;
353 1.10 mjacob case 5:
354 1.10 mjacob revname = "1040B";
355 1.10 mjacob isp->isp_type = ISP_HA_SCSI_1040B;
356 1.36 mjacob isp->isp_clock = 60;
357 1.10 mjacob break;
358 1.35 mjacob case 6:
359 1.44 mjacob revname = "1040C";
360 1.35 mjacob isp->isp_type = ISP_HA_SCSI_1040C;
361 1.36 mjacob isp->isp_clock = 60;
362 1.35 mjacob break;
363 1.8 mjacob }
364 1.25 mjacob /*
365 1.31 mjacob * Now, while we're at it, gather info about ultra
366 1.31 mjacob * and/or differential mode.
367 1.25 mjacob */
368 1.31 mjacob if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
369 1.57 mjacob isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
370 1.31 mjacob sdp->isp_diffmode = 1;
371 1.31 mjacob } else {
372 1.31 mjacob sdp->isp_diffmode = 0;
373 1.31 mjacob }
374 1.31 mjacob i = ISP_READ(isp, RISC_PSR);
375 1.31 mjacob if (isp->isp_bustype == ISP_BT_SBUS) {
376 1.31 mjacob i &= RISC_PSR_SBUS_ULTRA;
377 1.30 mjacob } else {
378 1.31 mjacob i &= RISC_PSR_PCI_ULTRA;
379 1.31 mjacob }
380 1.31 mjacob if (i != 0) {
381 1.57 mjacob isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
382 1.31 mjacob sdp->isp_ultramode = 1;
383 1.33 mjacob /*
384 1.33 mjacob * If we're in Ultra Mode, we have to be 60Mhz clock-
385 1.33 mjacob * even for the SBus version.
386 1.33 mjacob */
387 1.36 mjacob isp->isp_clock = 60;
388 1.34 mjacob } else {
389 1.31 mjacob sdp->isp_ultramode = 0;
390 1.33 mjacob /*
391 1.33 mjacob * Clock is known. Gronk.
392 1.33 mjacob */
393 1.25 mjacob }
394 1.25 mjacob
395 1.25 mjacob /*
396 1.25 mjacob * Machine dependent clock (if set) overrides
397 1.25 mjacob * our generic determinations.
398 1.25 mjacob */
399 1.25 mjacob if (isp->isp_mdvec->dv_clock) {
400 1.36 mjacob if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
401 1.36 mjacob isp->isp_clock = isp->isp_mdvec->dv_clock;
402 1.25 mjacob }
403 1.25 mjacob }
404 1.31 mjacob
405 1.4 mjacob }
406 1.8 mjacob
407 1.1 cgd /*
408 1.10 mjacob * Do MD specific pre initialization
409 1.1 cgd */
410 1.10 mjacob ISP_RESET0(isp);
411 1.25 mjacob
412 1.31 mjacob again:
413 1.30 mjacob
414 1.1 cgd /*
415 1.10 mjacob * Hit the chip over the head with hammer,
416 1.10 mjacob * and give the ISP a chance to recover.
417 1.1 cgd */
418 1.1 cgd
419 1.33 mjacob if (IS_SCSI(isp)) {
420 1.10 mjacob ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
421 1.10 mjacob /*
422 1.10 mjacob * A slight delay...
423 1.10 mjacob */
424 1.57 mjacob USEC_DELAY(100);
425 1.33 mjacob
426 1.10 mjacob /*
427 1.10 mjacob * Clear data && control DMA engines.
428 1.10 mjacob */
429 1.10 mjacob ISP_WRITE(isp, CDMA_CONTROL,
430 1.34 mjacob DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
431 1.10 mjacob ISP_WRITE(isp, DDMA_CONTROL,
432 1.34 mjacob DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
433 1.33 mjacob
434 1.33 mjacob
435 1.10 mjacob } else {
436 1.10 mjacob ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
437 1.10 mjacob /*
438 1.10 mjacob * A slight delay...
439 1.10 mjacob */
440 1.57 mjacob USEC_DELAY(100);
441 1.31 mjacob
442 1.31 mjacob /*
443 1.31 mjacob * Clear data && control DMA engines.
444 1.31 mjacob */
445 1.10 mjacob ISP_WRITE(isp, CDMA2100_CONTROL,
446 1.10 mjacob DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
447 1.10 mjacob ISP_WRITE(isp, TDMA2100_CONTROL,
448 1.10 mjacob DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
449 1.10 mjacob ISP_WRITE(isp, RDMA2100_CONTROL,
450 1.10 mjacob DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
451 1.10 mjacob }
452 1.10 mjacob
453 1.1 cgd /*
454 1.1 cgd * Wait for ISP to be ready to go...
455 1.1 cgd */
456 1.1 cgd loops = MBOX_DELAY_COUNT;
457 1.10 mjacob for (;;) {
458 1.38 mjacob if (IS_SCSI(isp)) {
459 1.10 mjacob if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET))
460 1.10 mjacob break;
461 1.10 mjacob } else {
462 1.10 mjacob if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
463 1.10 mjacob break;
464 1.10 mjacob }
465 1.57 mjacob USEC_DELAY(100);
466 1.1 cgd if (--loops < 0) {
467 1.57 mjacob ISP_DUMPREGS(isp, "chip reset timed out");
468 1.1 cgd return;
469 1.1 cgd }
470 1.1 cgd }
471 1.31 mjacob
472 1.1 cgd /*
473 1.31 mjacob * After we've fired this chip up, zero out the conf1 register
474 1.31 mjacob * for SCSI adapters and other settings for the 2100.
475 1.1 cgd */
476 1.31 mjacob
477 1.33 mjacob if (IS_SCSI(isp)) {
478 1.10 mjacob ISP_WRITE(isp, BIU_CONF1, 0);
479 1.10 mjacob } else {
480 1.10 mjacob ISP_WRITE(isp, BIU2100_CSR, 0);
481 1.10 mjacob }
482 1.1 cgd
483 1.31 mjacob /*
484 1.31 mjacob * Reset RISC Processor
485 1.31 mjacob */
486 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
487 1.57 mjacob USEC_DELAY(100);
488 1.1 cgd
489 1.30 mjacob /*
490 1.31 mjacob * Establish some initial burst rate stuff.
491 1.30 mjacob * (only for the 1XX0 boards). This really should
492 1.30 mjacob * be done later after fetching from NVRAM.
493 1.30 mjacob */
494 1.33 mjacob if (IS_SCSI(isp)) {
495 1.31 mjacob u_int16_t tmp = isp->isp_mdvec->dv_conf1;
496 1.30 mjacob /*
497 1.30 mjacob * Busted FIFO. Turn off all but burst enables.
498 1.30 mjacob */
499 1.30 mjacob if (isp->isp_type == ISP_HA_SCSI_1040A) {
500 1.31 mjacob tmp &= BIU_BURST_ENABLE;
501 1.30 mjacob }
502 1.31 mjacob ISP_SETBITS(isp, BIU_CONF1, tmp);
503 1.31 mjacob if (tmp & BIU_BURST_ENABLE) {
504 1.1 cgd ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
505 1.1 cgd ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
506 1.1 cgd }
507 1.31 mjacob #ifdef PTI_CARDS
508 1.31 mjacob if (((sdparam *) isp->isp_param)->isp_ultramode) {
509 1.34 mjacob while (ISP_READ(isp, RISC_MTR) != 0x1313) {
510 1.31 mjacob ISP_WRITE(isp, RISC_MTR, 0x1313);
511 1.31 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
512 1.31 mjacob }
513 1.34 mjacob } else {
514 1.31 mjacob ISP_WRITE(isp, RISC_MTR, 0x1212);
515 1.31 mjacob }
516 1.31 mjacob /*
517 1.31 mjacob * PTI specific register
518 1.31 mjacob */
519 1.31 mjacob ISP_WRITE(isp, RISC_EMB, DUAL_BANK)
520 1.31 mjacob #else
521 1.31 mjacob ISP_WRITE(isp, RISC_MTR, 0x1212);
522 1.31 mjacob #endif
523 1.31 mjacob } else {
524 1.31 mjacob ISP_WRITE(isp, RISC_MTR2100, 0x1212);
525 1.1 cgd }
526 1.31 mjacob
527 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
528 1.1 cgd
529 1.1 cgd /*
530 1.1 cgd * Do MD specific post initialization
531 1.1 cgd */
532 1.1 cgd ISP_RESET1(isp);
533 1.1 cgd
534 1.1 cgd /*
535 1.31 mjacob * Wait for everything to finish firing up...
536 1.31 mjacob */
537 1.31 mjacob loops = MBOX_DELAY_COUNT;
538 1.31 mjacob while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
539 1.57 mjacob USEC_DELAY(100);
540 1.31 mjacob if (--loops < 0) {
541 1.57 mjacob isp_prt(isp, ISP_LOGERR,
542 1.57 mjacob "MBOX_BUSY never cleared on reset");
543 1.31 mjacob return;
544 1.31 mjacob }
545 1.31 mjacob }
546 1.31 mjacob
547 1.31 mjacob /*
548 1.31 mjacob * Up until this point we've done everything by just reading or
549 1.31 mjacob * setting registers. From this point on we rely on at least *some*
550 1.31 mjacob * kind of firmware running in the card.
551 1.31 mjacob */
552 1.31 mjacob
553 1.31 mjacob /*
554 1.1 cgd * Do some sanity checking.
555 1.1 cgd */
556 1.1 cgd mbs.param[0] = MBOX_NO_OP;
557 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
558 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
559 1.1 cgd return;
560 1.1 cgd }
561 1.1 cgd
562 1.37 mjacob if (IS_SCSI(isp)) {
563 1.10 mjacob mbs.param[0] = MBOX_MAILBOX_REG_TEST;
564 1.10 mjacob mbs.param[1] = 0xdead;
565 1.10 mjacob mbs.param[2] = 0xbeef;
566 1.10 mjacob mbs.param[3] = 0xffff;
567 1.10 mjacob mbs.param[4] = 0x1111;
568 1.10 mjacob mbs.param[5] = 0xa5a5;
569 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
570 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
571 1.10 mjacob return;
572 1.10 mjacob }
573 1.10 mjacob if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
574 1.10 mjacob mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
575 1.10 mjacob mbs.param[5] != 0xa5a5) {
576 1.57 mjacob isp_prt(isp, ISP_LOGERR,
577 1.57 mjacob "Register Test Failed (0x%x 0x%x 0x%x 0x%x 0x%x)",
578 1.57 mjacob mbs.param[1], mbs.param[2], mbs.param[3],
579 1.57 mjacob mbs.param[4], mbs.param[5]);
580 1.1 cgd return;
581 1.1 cgd }
582 1.10 mjacob
583 1.1 cgd }
584 1.1 cgd
585 1.1 cgd /*
586 1.18 mjacob * Download new Firmware, unless requested not to do so.
587 1.18 mjacob * This is made slightly trickier in some cases where the
588 1.18 mjacob * firmware of the ROM revision is newer than the revision
589 1.18 mjacob * compiled into the driver. So, where we used to compare
590 1.18 mjacob * versions of our f/w and the ROM f/w, now we just see
591 1.18 mjacob * whether we have f/w at all and whether a config flag
592 1.18 mjacob * has disabled our download.
593 1.1 cgd */
594 1.43 mjacob if ((isp->isp_mdvec->dv_ispfw == NULL) ||
595 1.23 mjacob (isp->isp_confopts & ISP_CFG_NORELOAD)) {
596 1.10 mjacob dodnld = 0;
597 1.10 mjacob }
598 1.10 mjacob
599 1.43 mjacob if (dodnld) {
600 1.57 mjacob u_int16_t fwlen = isp->isp_mdvec->dv_ispfw[3];
601 1.43 mjacob for (i = 0; i < fwlen; i++) {
602 1.10 mjacob mbs.param[0] = MBOX_WRITE_RAM_WORD;
603 1.57 mjacob mbs.param[1] = ISP_CODE_ORG + i;
604 1.10 mjacob mbs.param[2] = isp->isp_mdvec->dv_ispfw[i];
605 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGNONE);
606 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
607 1.57 mjacob isp_prt(isp, ISP_LOGERR,
608 1.57 mjacob "F/W download failed at word %d", i);
609 1.31 mjacob dodnld = 0;
610 1.31 mjacob goto again;
611 1.10 mjacob }
612 1.10 mjacob }
613 1.10 mjacob
614 1.31 mjacob /*
615 1.31 mjacob * Verify that it downloaded correctly.
616 1.31 mjacob */
617 1.31 mjacob mbs.param[0] = MBOX_VERIFY_CHECKSUM;
618 1.57 mjacob mbs.param[1] = ISP_CODE_ORG;
619 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGNONE);
620 1.31 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
621 1.57 mjacob isp_prt(isp, ISP_LOGERR, "Ram Checksum Failure");
622 1.31 mjacob return;
623 1.10 mjacob }
624 1.58 mjacob isp->isp_loaded_fw = 1;
625 1.10 mjacob } else {
626 1.58 mjacob isp->isp_loaded_fw = 0;
627 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
628 1.1 cgd }
629 1.1 cgd
630 1.1 cgd /*
631 1.10 mjacob * Now start it rolling.
632 1.10 mjacob *
633 1.10 mjacob * If we didn't actually download f/w,
634 1.10 mjacob * we still need to (re)start it.
635 1.1 cgd */
636 1.1 cgd
637 1.1 cgd mbs.param[0] = MBOX_EXEC_FIRMWARE;
638 1.57 mjacob mbs.param[1] = ISP_CODE_ORG;
639 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGNONE);
640 1.54 mjacob /* give it a chance to start */
641 1.57 mjacob USEC_DELAY(500);
642 1.4 mjacob
643 1.38 mjacob if (IS_SCSI(isp)) {
644 1.10 mjacob /*
645 1.25 mjacob * Set CLOCK RATE, but only if asked to.
646 1.10 mjacob */
647 1.36 mjacob if (isp->isp_clock) {
648 1.10 mjacob mbs.param[0] = MBOX_SET_CLOCK_RATE;
649 1.36 mjacob mbs.param[1] = isp->isp_clock;
650 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
651 1.57 mjacob /* we will try not to care if this fails */
652 1.4 mjacob }
653 1.4 mjacob }
654 1.57 mjacob
655 1.1 cgd mbs.param[0] = MBOX_ABOUT_FIRMWARE;
656 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
657 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
658 1.1 cgd return;
659 1.1 cgd }
660 1.57 mjacob isp_prt(isp, ISP_LOGCONFIG,
661 1.57 mjacob "Board Revision %s, %s F/W Revision %d.%d.%d", revname,
662 1.57 mjacob dodnld? "loaded" : "resident", mbs.param[1], mbs.param[2],
663 1.57 mjacob mbs.param[3]);
664 1.34 mjacob if (IS_FC(isp)) {
665 1.32 mjacob if (ISP_READ(isp, BIU2100_CSR) & BIU2100_PCI64) {
666 1.57 mjacob isp_prt(isp, ISP_LOGCONFIG,
667 1.57 mjacob "Installed in 64-Bit PCI slot");
668 1.32 mjacob }
669 1.32 mjacob }
670 1.38 mjacob
671 1.35 mjacob isp->isp_fwrev[0] = mbs.param[1];
672 1.35 mjacob isp->isp_fwrev[1] = mbs.param[2];
673 1.35 mjacob isp->isp_fwrev[2] = mbs.param[3];
674 1.35 mjacob if (isp->isp_romfw_rev[0] || isp->isp_romfw_rev[1] ||
675 1.35 mjacob isp->isp_romfw_rev[2]) {
676 1.57 mjacob isp_prt(isp, ISP_LOGCONFIG, "Last F/W revision was %d.%d.%d",
677 1.35 mjacob isp->isp_romfw_rev[0], isp->isp_romfw_rev[1],
678 1.35 mjacob isp->isp_romfw_rev[2]);
679 1.25 mjacob }
680 1.38 mjacob
681 1.38 mjacob mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
682 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
683 1.38 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
684 1.38 mjacob return;
685 1.38 mjacob }
686 1.38 mjacob isp->isp_maxcmds = mbs.param[2];
687 1.57 mjacob isp_prt(isp, ISP_LOGINFO,
688 1.57 mjacob "%d max I/O commands supported", mbs.param[2]);
689 1.10 mjacob isp_fw_state(isp);
690 1.38 mjacob
691 1.36 mjacob /*
692 1.36 mjacob * Set up DMA for the request and result mailboxes.
693 1.36 mjacob */
694 1.36 mjacob if (ISP_MBOXDMASETUP(isp) != 0) {
695 1.57 mjacob isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
696 1.36 mjacob return;
697 1.36 mjacob }
698 1.1 cgd isp->isp_state = ISP_RESETSTATE;
699 1.54 mjacob
700 1.54 mjacob /*
701 1.54 mjacob * Okay- now that we have new firmware running, we now (re)set our
702 1.54 mjacob * notion of how many luns we support. This is somewhat tricky because
703 1.54 mjacob * if we haven't loaded firmware, we don't have an easy way of telling
704 1.54 mjacob * how many luns we support.
705 1.54 mjacob *
706 1.54 mjacob * We'll make a simplifying assumption- if we loaded firmware, we
707 1.54 mjacob * are running with expanded lun firmware, otherwise not.
708 1.54 mjacob *
709 1.54 mjacob * Expanded lun firmware gives you 32 luns for SCSI cards and
710 1.54 mjacob * 65536 luns for Fibre Channel cards.
711 1.54 mjacob *
712 1.54 mjacob * Because the lun is in a a different position in the Request Queue
713 1.54 mjacob * Entry structure for Fibre Channel with expanded lun firmware, we
714 1.54 mjacob * can only support one lun (lun zero) when we don't know what kind
715 1.54 mjacob * of firmware we're running.
716 1.54 mjacob *
717 1.54 mjacob * Note that we only do this once (the first time thru isp_reset)
718 1.54 mjacob * because we may be called again after firmware has been loaded once
719 1.54 mjacob * and released.
720 1.54 mjacob */
721 1.54 mjacob if (touched == 0) {
722 1.54 mjacob if (dodnld) {
723 1.54 mjacob if (IS_SCSI(isp)) {
724 1.54 mjacob isp->isp_maxluns = 32;
725 1.54 mjacob } else {
726 1.54 mjacob isp->isp_maxluns = 65536;
727 1.54 mjacob }
728 1.54 mjacob } else {
729 1.54 mjacob if (IS_SCSI(isp)) {
730 1.54 mjacob isp->isp_maxluns = 8;
731 1.54 mjacob } else {
732 1.57 mjacob isp_prt(isp, ISP_LOGALL, warnlun);
733 1.54 mjacob isp->isp_maxluns = 1;
734 1.54 mjacob }
735 1.54 mjacob }
736 1.54 mjacob }
737 1.1 cgd }
738 1.1 cgd
739 1.1 cgd /*
740 1.31 mjacob * Initialize Parameters of Hardware to a known state.
741 1.24 mjacob *
742 1.24 mjacob * Locks are held before coming here.
743 1.1 cgd */
744 1.24 mjacob
745 1.1 cgd void
746 1.1 cgd isp_init(isp)
747 1.1 cgd struct ispsoftc *isp;
748 1.1 cgd {
749 1.36 mjacob /*
750 1.36 mjacob * Must do this first to get defaults established.
751 1.36 mjacob */
752 1.36 mjacob isp_setdfltparm(isp, 0);
753 1.44 mjacob if (IS_DUALBUS(isp)) {
754 1.36 mjacob isp_setdfltparm(isp, 1);
755 1.36 mjacob }
756 1.36 mjacob if (IS_FC(isp)) {
757 1.36 mjacob isp_fibre_init(isp);
758 1.36 mjacob } else {
759 1.36 mjacob isp_scsi_init(isp);
760 1.36 mjacob }
761 1.36 mjacob }
762 1.36 mjacob
763 1.36 mjacob static void
764 1.36 mjacob isp_scsi_init(isp)
765 1.36 mjacob struct ispsoftc *isp;
766 1.36 mjacob {
767 1.36 mjacob sdparam *sdp_chan0, *sdp_chan1;
768 1.1 cgd mbreg_t mbs;
769 1.36 mjacob
770 1.36 mjacob sdp_chan0 = isp->isp_param;
771 1.36 mjacob sdp_chan1 = sdp_chan0;
772 1.44 mjacob if (IS_DUALBUS(isp)) {
773 1.36 mjacob sdp_chan1++;
774 1.36 mjacob }
775 1.36 mjacob
776 1.36 mjacob /* First do overall per-card settings. */
777 1.25 mjacob
778 1.25 mjacob /*
779 1.36 mjacob * If we have fast memory timing enabled, turn it on.
780 1.25 mjacob */
781 1.58 mjacob if (sdp_chan0->isp_fast_mttr) {
782 1.36 mjacob ISP_WRITE(isp, RISC_MTR, 0x1313);
783 1.36 mjacob }
784 1.25 mjacob
785 1.25 mjacob /*
786 1.36 mjacob * Set Retry Delay and Count.
787 1.36 mjacob * You set both channels at the same time.
788 1.33 mjacob */
789 1.36 mjacob mbs.param[0] = MBOX_SET_RETRY_COUNT;
790 1.36 mjacob mbs.param[1] = sdp_chan0->isp_retry_count;
791 1.36 mjacob mbs.param[2] = sdp_chan0->isp_retry_delay;
792 1.36 mjacob mbs.param[6] = sdp_chan1->isp_retry_count;
793 1.36 mjacob mbs.param[7] = sdp_chan1->isp_retry_delay;
794 1.36 mjacob
795 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
796 1.36 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
797 1.33 mjacob return;
798 1.33 mjacob }
799 1.34 mjacob
800 1.33 mjacob /*
801 1.36 mjacob * Set ASYNC DATA SETUP time. This is very important.
802 1.25 mjacob */
803 1.36 mjacob mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
804 1.36 mjacob mbs.param[1] = sdp_chan0->isp_async_data_setup;
805 1.36 mjacob mbs.param[2] = sdp_chan1->isp_async_data_setup;
806 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
807 1.36 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
808 1.10 mjacob return;
809 1.1 cgd }
810 1.1 cgd
811 1.10 mjacob /*
812 1.36 mjacob * Set ACTIVE Negation State.
813 1.32 mjacob */
814 1.36 mjacob mbs.param[0] = MBOX_SET_ACT_NEG_STATE;
815 1.36 mjacob mbs.param[1] =
816 1.36 mjacob (sdp_chan0->isp_req_ack_active_neg << 4) |
817 1.36 mjacob (sdp_chan0->isp_data_line_active_neg << 5);
818 1.36 mjacob mbs.param[2] =
819 1.36 mjacob (sdp_chan1->isp_req_ack_active_neg << 4) |
820 1.36 mjacob (sdp_chan1->isp_data_line_active_neg << 5);
821 1.36 mjacob
822 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGNONE);
823 1.36 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
824 1.57 mjacob isp_prt(isp, ISP_LOGERR,
825 1.57 mjacob "failed to set active negation state (%d,%d), (%d,%d)",
826 1.36 mjacob sdp_chan0->isp_req_ack_active_neg,
827 1.36 mjacob sdp_chan0->isp_data_line_active_neg,
828 1.36 mjacob sdp_chan1->isp_req_ack_active_neg,
829 1.36 mjacob sdp_chan1->isp_data_line_active_neg);
830 1.36 mjacob /*
831 1.36 mjacob * But don't return.
832 1.36 mjacob */
833 1.32 mjacob }
834 1.32 mjacob
835 1.32 mjacob /*
836 1.36 mjacob * Set the Tag Aging limit
837 1.10 mjacob */
838 1.36 mjacob mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
839 1.36 mjacob mbs.param[1] = sdp_chan0->isp_tag_aging;
840 1.36 mjacob mbs.param[2] = sdp_chan1->isp_tag_aging;
841 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
842 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
843 1.57 mjacob isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
844 1.57 mjacob sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
845 1.1 cgd return;
846 1.1 cgd }
847 1.1 cgd
848 1.25 mjacob /*
849 1.36 mjacob * Set selection timeout.
850 1.25 mjacob */
851 1.36 mjacob mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
852 1.36 mjacob mbs.param[1] = sdp_chan0->isp_selection_timeout;
853 1.36 mjacob mbs.param[2] = sdp_chan1->isp_selection_timeout;
854 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
855 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
856 1.1 cgd return;
857 1.1 cgd }
858 1.1 cgd
859 1.36 mjacob /* now do per-channel settings */
860 1.36 mjacob isp_scsi_channel_init(isp, 0);
861 1.44 mjacob if (IS_DUALBUS(isp))
862 1.36 mjacob isp_scsi_channel_init(isp, 1);
863 1.36 mjacob
864 1.25 mjacob /*
865 1.36 mjacob * Now enable request/response queues
866 1.25 mjacob */
867 1.36 mjacob
868 1.36 mjacob mbs.param[0] = MBOX_INIT_RES_QUEUE;
869 1.57 mjacob mbs.param[1] = RESULT_QUEUE_LEN(isp);
870 1.36 mjacob mbs.param[2] = DMA_MSW(isp->isp_result_dma);
871 1.36 mjacob mbs.param[3] = DMA_LSW(isp->isp_result_dma);
872 1.36 mjacob mbs.param[4] = 0;
873 1.36 mjacob mbs.param[5] = 0;
874 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
875 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
876 1.1 cgd return;
877 1.1 cgd }
878 1.62 mjacob isp->isp_residx = mbs.param[5];
879 1.1 cgd
880 1.36 mjacob mbs.param[0] = MBOX_INIT_REQ_QUEUE;
881 1.57 mjacob mbs.param[1] = RQUEST_QUEUE_LEN(isp);
882 1.36 mjacob mbs.param[2] = DMA_MSW(isp->isp_rquest_dma);
883 1.36 mjacob mbs.param[3] = DMA_LSW(isp->isp_rquest_dma);
884 1.36 mjacob mbs.param[4] = 0;
885 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
886 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
887 1.1 cgd return;
888 1.1 cgd }
889 1.62 mjacob isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
890 1.1 cgd
891 1.25 mjacob /*
892 1.45 mjacob * Turn on Fast Posting, LVD transitions
893 1.45 mjacob *
894 1.45 mjacob * Ultra2 F/W always has had fast posting (and LVD transitions)
895 1.45 mjacob *
896 1.50 mjacob * Ultra and older (i.e., SBus) cards may not. It's just safer
897 1.50 mjacob * to assume not for them.
898 1.25 mjacob */
899 1.25 mjacob
900 1.45 mjacob mbs.param[0] = MBOX_SET_FW_FEATURES;
901 1.45 mjacob mbs.param[1] = 0;
902 1.45 mjacob if (IS_ULTRA2(isp))
903 1.45 mjacob mbs.param[1] |= FW_FEATURE_LVD_NOTIFY;
904 1.49 mjacob if (IS_ULTRA2(isp) || IS_1240(isp))
905 1.49 mjacob mbs.param[1] |= FW_FEATURE_FAST_POST;
906 1.45 mjacob if (mbs.param[1] != 0) {
907 1.45 mjacob u_int16_t sfeat = mbs.param[1];
908 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
909 1.57 mjacob if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
910 1.57 mjacob isp_prt(isp, ISP_LOGINFO,
911 1.57 mjacob "Enabled FW features (0x%x)", sfeat);
912 1.36 mjacob }
913 1.1 cgd }
914 1.1 cgd
915 1.25 mjacob /*
916 1.36 mjacob * Let the outer layers decide whether to issue a SCSI bus reset.
917 1.25 mjacob */
918 1.36 mjacob isp->isp_state = ISP_INITSTATE;
919 1.36 mjacob }
920 1.25 mjacob
921 1.36 mjacob static void
922 1.36 mjacob isp_scsi_channel_init(isp, channel)
923 1.36 mjacob struct ispsoftc *isp;
924 1.36 mjacob int channel;
925 1.36 mjacob {
926 1.36 mjacob sdparam *sdp;
927 1.36 mjacob mbreg_t mbs;
928 1.36 mjacob int tgt;
929 1.36 mjacob
930 1.36 mjacob sdp = isp->isp_param;
931 1.36 mjacob sdp += channel;
932 1.36 mjacob
933 1.36 mjacob /*
934 1.36 mjacob * Set (possibly new) Initiator ID.
935 1.36 mjacob */
936 1.36 mjacob mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
937 1.36 mjacob mbs.param[1] = (channel << 7) | sdp->isp_initiator_id;
938 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
939 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
940 1.1 cgd return;
941 1.1 cgd }
942 1.62 mjacob isp_prt(isp, ISP_LOGINFO, "Initiator ID is %d", sdp->isp_initiator_id);
943 1.62 mjacob
944 1.1 cgd
945 1.25 mjacob /*
946 1.32 mjacob * Set current per-target parameters to a safe minimum.
947 1.25 mjacob */
948 1.25 mjacob for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
949 1.54 mjacob int lun;
950 1.32 mjacob u_int16_t sdf;
951 1.10 mjacob
952 1.36 mjacob if (sdp->isp_devparam[tgt].dev_enable == 0) {
953 1.1 cgd continue;
954 1.36 mjacob }
955 1.58 mjacob sdf = DPARM_SAFE_DFLT;
956 1.36 mjacob /*
957 1.58 mjacob * It is not quite clear when this changed over so that
958 1.58 mjacob * we could force narrow and async for 1000/1020 cards,
959 1.58 mjacob * but assume that this is only the case for loaded
960 1.58 mjacob * firmware.
961 1.36 mjacob */
962 1.58 mjacob if (isp->isp_loaded_fw) {
963 1.58 mjacob sdf |= DPARM_NARROW | DPARM_ASYNC;
964 1.20 mjacob }
965 1.32 mjacob mbs.param[0] = MBOX_SET_TARGET_PARAMS;
966 1.36 mjacob mbs.param[1] = (tgt << 8) | (channel << 15);
967 1.32 mjacob mbs.param[2] = sdf;
968 1.58 mjacob if ((sdf & DPARM_SYNC) == 0) {
969 1.58 mjacob mbs.param[3] = 0;
970 1.58 mjacob } else {
971 1.58 mjacob mbs.param[3] =
972 1.58 mjacob (sdp->isp_devparam[tgt].sync_offset << 8) |
973 1.58 mjacob (sdp->isp_devparam[tgt].sync_period);
974 1.58 mjacob }
975 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
976 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
977 1.32 mjacob sdf = DPARM_SAFE_DFLT;
978 1.10 mjacob mbs.param[0] = MBOX_SET_TARGET_PARAMS;
979 1.36 mjacob mbs.param[1] = (tgt << 8) | (channel << 15);
980 1.32 mjacob mbs.param[2] = sdf;
981 1.58 mjacob mbs.param[3] = 0;
982 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
983 1.10 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
984 1.25 mjacob continue;
985 1.10 mjacob }
986 1.1 cgd }
987 1.45 mjacob
988 1.34 mjacob /*
989 1.58 mjacob * We don't update any information directly from the f/w
990 1.58 mjacob * because we need to run at least one command to cause a
991 1.58 mjacob * new state to be latched up. So, we just assume that we
992 1.58 mjacob * converge to the values we just had set.
993 1.58 mjacob *
994 1.34 mjacob * Ensure that we don't believe tagged queuing is enabled yet.
995 1.34 mjacob * It turns out that sometimes the ISP just ignores our
996 1.34 mjacob * attempts to set parameters for devices that it hasn't
997 1.34 mjacob * seen yet.
998 1.34 mjacob */
999 1.58 mjacob sdp->isp_devparam[tgt].cur_dflags = sdf & ~DPARM_TQING;
1000 1.57 mjacob for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1001 1.1 cgd mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
1002 1.36 mjacob mbs.param[1] = (channel << 15) | (tgt << 8) | lun;
1003 1.10 mjacob mbs.param[2] = sdp->isp_max_queue_depth;
1004 1.25 mjacob mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
1005 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
1006 1.1 cgd if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1007 1.25 mjacob break;
1008 1.1 cgd }
1009 1.1 cgd }
1010 1.31 mjacob }
1011 1.60 mjacob for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1012 1.60 mjacob if (sdp->isp_devparam[tgt].dev_refresh) {
1013 1.60 mjacob isp->isp_sendmarker |= (1 << channel);
1014 1.60 mjacob isp->isp_update |= (1 << channel);
1015 1.60 mjacob break;
1016 1.60 mjacob }
1017 1.60 mjacob }
1018 1.1 cgd }
1019 1.1 cgd
1020 1.24 mjacob /*
1021 1.24 mjacob * Fibre Channel specific initialization.
1022 1.24 mjacob *
1023 1.24 mjacob * Locks are held before coming here.
1024 1.24 mjacob */
1025 1.10 mjacob static void
1026 1.10 mjacob isp_fibre_init(isp)
1027 1.10 mjacob struct ispsoftc *isp;
1028 1.10 mjacob {
1029 1.10 mjacob fcparam *fcp;
1030 1.10 mjacob isp_icb_t *icbp;
1031 1.10 mjacob mbreg_t mbs;
1032 1.37 mjacob int loopid;
1033 1.62 mjacob u_int64_t nwwn, pwwn;
1034 1.10 mjacob
1035 1.10 mjacob fcp = isp->isp_param;
1036 1.10 mjacob
1037 1.37 mjacob loopid = DEFAULT_LOOPID(isp);
1038 1.10 mjacob icbp = (isp_icb_t *) fcp->isp_scratch;
1039 1.30 mjacob MEMZERO(icbp, sizeof (*icbp));
1040 1.25 mjacob
1041 1.25 mjacob icbp->icb_version = ICB_VERSION1;
1042 1.58 mjacob
1043 1.58 mjacob /*
1044 1.58 mjacob * Firmware Options are either retrieved from NVRAM or
1045 1.58 mjacob * are patched elsewhere. We check them for sanity here
1046 1.58 mjacob * and make changes based on board revision, but otherwise
1047 1.58 mjacob * let others decide policy.
1048 1.58 mjacob */
1049 1.58 mjacob
1050 1.43 mjacob /*
1051 1.43 mjacob * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
1052 1.43 mjacob */
1053 1.43 mjacob if ((isp->isp_type == ISP_HA_FC_2100) && isp->isp_revision < 5) {
1054 1.43 mjacob fcp->isp_fwoptions &= ~ICBOPT_FAIRNESS;
1055 1.43 mjacob }
1056 1.58 mjacob
1057 1.37 mjacob /*
1058 1.38 mjacob * We have to use FULL LOGIN even though it resets the loop too much
1059 1.38 mjacob * because otherwise port database entries don't get updated after
1060 1.52 he * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
1061 1.37 mjacob */
1062 1.38 mjacob if (ISP_FW_REVX(isp->isp_fwrev) < ISP_FW_REV(1, 17, 0)) {
1063 1.38 mjacob fcp->isp_fwoptions |= ICBOPT_FULL_LOGIN;
1064 1.38 mjacob }
1065 1.37 mjacob
1066 1.37 mjacob /*
1067 1.60 mjacob * Insist on Port Database Update Async notifications
1068 1.60 mjacob */
1069 1.60 mjacob fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
1070 1.60 mjacob
1071 1.60 mjacob /*
1072 1.37 mjacob * We don't set ICBOPT_PORTNAME because we want our
1073 1.37 mjacob * Node Name && Port Names to be distinct.
1074 1.37 mjacob */
1075 1.31 mjacob
1076 1.27 mjacob icbp->icb_fwoptions = fcp->isp_fwoptions;
1077 1.25 mjacob icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
1078 1.25 mjacob if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
1079 1.25 mjacob icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1080 1.57 mjacob isp_prt(isp, ISP_LOGERR,
1081 1.57 mjacob "bad frame length (%d) from NVRAM- using %d",
1082 1.57 mjacob fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
1083 1.35 mjacob icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1084 1.25 mjacob }
1085 1.25 mjacob icbp->icb_maxalloc = fcp->isp_maxalloc;
1086 1.37 mjacob if (icbp->icb_maxalloc < 1) {
1087 1.57 mjacob isp_prt(isp, ISP_LOGERR,
1088 1.57 mjacob "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1089 1.35 mjacob icbp->icb_maxalloc = 16;
1090 1.35 mjacob }
1091 1.25 mjacob icbp->icb_execthrottle = fcp->isp_execthrottle;
1092 1.35 mjacob if (icbp->icb_execthrottle < 1) {
1093 1.57 mjacob isp_prt(isp, ISP_LOGERR,
1094 1.57 mjacob "bad execution throttle of %d- using 16",
1095 1.57 mjacob fcp->isp_execthrottle);
1096 1.37 mjacob icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1097 1.35 mjacob }
1098 1.25 mjacob icbp->icb_retry_delay = fcp->isp_retry_delay;
1099 1.25 mjacob icbp->icb_retry_count = fcp->isp_retry_count;
1100 1.28 mjacob icbp->icb_hardaddr = loopid;
1101 1.58 mjacob /*
1102 1.58 mjacob * Right now we just set extended options to prefer point-to-point
1103 1.58 mjacob * over loop based upon some soft config options.
1104 1.58 mjacob */
1105 1.49 mjacob if (IS_2200(isp)) {
1106 1.49 mjacob icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1107 1.49 mjacob /*
1108 1.49 mjacob * Prefer or force Point-To-Point instead Loop?
1109 1.49 mjacob */
1110 1.49 mjacob if (isp->isp_confopts & ISP_CFG_NPORT)
1111 1.49 mjacob icbp->icb_xfwoptions = ICBXOPT_PTP_2_LOOP;
1112 1.49 mjacob else
1113 1.49 mjacob icbp->icb_xfwoptions = ICBXOPT_LOOP_2_PTP;
1114 1.49 mjacob }
1115 1.46 mjacob icbp->icb_logintime = 60; /* 60 second login timeout */
1116 1.25 mjacob
1117 1.62 mjacob nwwn = ISP_NODEWWN(isp);
1118 1.62 mjacob pwwn = ISP_PORTWWN(isp);
1119 1.62 mjacob if (nwwn && pwwn) {
1120 1.62 mjacob MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn);
1121 1.62 mjacob MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1122 1.62 mjacob isp_prt(isp, ISP_LOGDEBUG1,
1123 1.62 mjacob "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1124 1.62 mjacob ((u_int32_t) (nwwn >> 32)),
1125 1.62 mjacob ((u_int32_t) (nwwn & 0xffffffff)),
1126 1.62 mjacob ((u_int32_t) (pwwn >> 32)),
1127 1.62 mjacob ((u_int32_t) (pwwn & 0xffffffff)));
1128 1.35 mjacob } else {
1129 1.62 mjacob isp_prt(isp, ISP_LOGDEBUG1, "Not using any WWNs");
1130 1.35 mjacob fcp->isp_fwoptions &= ~(ICBOPT_USE_PORTNAME|ICBOPT_FULL_LOGIN);
1131 1.28 mjacob }
1132 1.57 mjacob icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1133 1.57 mjacob icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1134 1.35 mjacob icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_LSW(isp->isp_rquest_dma);
1135 1.35 mjacob icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_MSW(isp->isp_rquest_dma);
1136 1.35 mjacob icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_LSW(isp->isp_result_dma);
1137 1.35 mjacob icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_MSW(isp->isp_result_dma);
1138 1.60 mjacob isp_prt(isp, ISP_LOGDEBUG1,
1139 1.60 mjacob "isp_fibre_init: fwoptions 0x%x", fcp->isp_fwoptions);
1140 1.38 mjacob ISP_SWIZZLE_ICB(isp, icbp);
1141 1.38 mjacob
1142 1.38 mjacob /*
1143 1.38 mjacob * Do this *before* initializing the firmware.
1144 1.38 mjacob */
1145 1.38 mjacob isp_mark_getpdb_all(isp);
1146 1.38 mjacob fcp->isp_fwstate = FW_CONFIG_WAIT;
1147 1.38 mjacob fcp->isp_loopstate = LOOP_NIL;
1148 1.38 mjacob
1149 1.57 mjacob mbs.param[0] = MBOX_INIT_FIRMWARE;
1150 1.57 mjacob mbs.param[1] = 0;
1151 1.57 mjacob mbs.param[2] = DMA_MSW(fcp->isp_scdma);
1152 1.57 mjacob mbs.param[3] = DMA_LSW(fcp->isp_scdma);
1153 1.57 mjacob mbs.param[4] = 0;
1154 1.57 mjacob mbs.param[5] = 0;
1155 1.57 mjacob mbs.param[6] = 0;
1156 1.57 mjacob mbs.param[7] = 0;
1157 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
1158 1.57 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1159 1.57 mjacob return;
1160 1.10 mjacob }
1161 1.25 mjacob isp->isp_reqidx = isp->isp_reqodx = 0;
1162 1.10 mjacob isp->isp_residx = 0;
1163 1.33 mjacob isp->isp_sendmarker = 1;
1164 1.33 mjacob
1165 1.33 mjacob /*
1166 1.33 mjacob * Whatever happens, we're now committed to being here.
1167 1.33 mjacob */
1168 1.33 mjacob isp->isp_state = ISP_INITSTATE;
1169 1.33 mjacob }
1170 1.33 mjacob
1171 1.33 mjacob /*
1172 1.33 mjacob * Fibre Channel Support- get the port database for the id.
1173 1.33 mjacob *
1174 1.33 mjacob * Locks are held before coming here. Return 0 if success,
1175 1.33 mjacob * else failure.
1176 1.33 mjacob */
1177 1.33 mjacob
1178 1.33 mjacob static void
1179 1.33 mjacob isp_mark_getpdb_all(isp)
1180 1.33 mjacob struct ispsoftc *isp;
1181 1.33 mjacob {
1182 1.33 mjacob fcparam *fcp = (fcparam *) isp->isp_param;
1183 1.37 mjacob int i;
1184 1.37 mjacob for (i = 0; i < MAX_FC_TARG; i++) {
1185 1.37 mjacob fcp->portdb[i].valid = 0;
1186 1.33 mjacob }
1187 1.33 mjacob }
1188 1.33 mjacob
1189 1.33 mjacob static int
1190 1.33 mjacob isp_getpdb(isp, id, pdbp)
1191 1.33 mjacob struct ispsoftc *isp;
1192 1.33 mjacob int id;
1193 1.33 mjacob isp_pdb_t *pdbp;
1194 1.33 mjacob {
1195 1.33 mjacob fcparam *fcp = (fcparam *) isp->isp_param;
1196 1.33 mjacob mbreg_t mbs;
1197 1.37 mjacob
1198 1.33 mjacob mbs.param[0] = MBOX_GET_PORT_DB;
1199 1.33 mjacob mbs.param[1] = id << 8;
1200 1.35 mjacob mbs.param[2] = DMA_MSW(fcp->isp_scdma);
1201 1.35 mjacob mbs.param[3] = DMA_LSW(fcp->isp_scdma);
1202 1.34 mjacob /*
1203 1.34 mjacob * Unneeded. For the 2100, except for initializing f/w, registers
1204 1.34 mjacob * 4/5 have to not be written to.
1205 1.34 mjacob * mbs.param[4] = 0;
1206 1.34 mjacob * mbs.param[5] = 0;
1207 1.34 mjacob *
1208 1.34 mjacob */
1209 1.33 mjacob mbs.param[6] = 0;
1210 1.33 mjacob mbs.param[7] = 0;
1211 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
1212 1.57 mjacob if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1213 1.38 mjacob ISP_UNSWIZZLE_AND_COPY_PDBP(isp, pdbp, fcp->isp_scratch);
1214 1.57 mjacob return (0);
1215 1.33 mjacob }
1216 1.57 mjacob return (-1);
1217 1.33 mjacob }
1218 1.33 mjacob
1219 1.37 mjacob static u_int64_t
1220 1.37 mjacob isp_get_portname(isp, loopid, nodename)
1221 1.37 mjacob struct ispsoftc *isp;
1222 1.37 mjacob int loopid;
1223 1.37 mjacob int nodename;
1224 1.37 mjacob {
1225 1.37 mjacob u_int64_t wwn = 0;
1226 1.37 mjacob mbreg_t mbs;
1227 1.37 mjacob
1228 1.37 mjacob mbs.param[0] = MBOX_GET_PORT_NAME;
1229 1.37 mjacob mbs.param[1] = loopid << 8;
1230 1.37 mjacob if (nodename)
1231 1.37 mjacob mbs.param[1] |= 1;
1232 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
1233 1.37 mjacob if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1234 1.37 mjacob wwn =
1235 1.37 mjacob (((u_int64_t)(mbs.param[2] & 0xff)) << 56) |
1236 1.37 mjacob (((u_int64_t)(mbs.param[2] >> 8)) << 48) |
1237 1.37 mjacob (((u_int64_t)(mbs.param[3] & 0xff)) << 40) |
1238 1.37 mjacob (((u_int64_t)(mbs.param[3] >> 8)) << 32) |
1239 1.37 mjacob (((u_int64_t)(mbs.param[6] & 0xff)) << 24) |
1240 1.37 mjacob (((u_int64_t)(mbs.param[6] >> 8)) << 16) |
1241 1.37 mjacob (((u_int64_t)(mbs.param[7] & 0xff)) << 8) |
1242 1.37 mjacob (((u_int64_t)(mbs.param[7] >> 8)));
1243 1.37 mjacob }
1244 1.37 mjacob return (wwn);
1245 1.37 mjacob }
1246 1.37 mjacob
1247 1.33 mjacob /*
1248 1.33 mjacob * Make sure we have good FC link and know our Loop ID.
1249 1.33 mjacob */
1250 1.33 mjacob
1251 1.33 mjacob static int
1252 1.57 mjacob isp_fclink_test(isp, usdelay)
1253 1.33 mjacob struct ispsoftc *isp;
1254 1.57 mjacob int usdelay;
1255 1.33 mjacob {
1256 1.38 mjacob static char *toponames[] = {
1257 1.38 mjacob "Private Loop",
1258 1.38 mjacob "FL Port",
1259 1.38 mjacob "N-Port to N-Port",
1260 1.52 he "F Port",
1261 1.52 he "F Port (no FLOGI_ACC response)"
1262 1.38 mjacob };
1263 1.33 mjacob mbreg_t mbs;
1264 1.52 he int count;
1265 1.33 mjacob u_int8_t lwfs;
1266 1.33 mjacob fcparam *fcp;
1267 1.37 mjacob #if defined(ISP2100_FABRIC)
1268 1.37 mjacob isp_pdb_t pdb;
1269 1.37 mjacob #endif
1270 1.33 mjacob fcp = isp->isp_param;
1271 1.10 mjacob
1272 1.10 mjacob /*
1273 1.57 mjacob * XXX: Here is where we would start a 'loop dead' timeout
1274 1.57 mjacob */
1275 1.57 mjacob
1276 1.57 mjacob /*
1277 1.33 mjacob * Wait up to N microseconds for F/W to go to a ready state.
1278 1.10 mjacob */
1279 1.23 mjacob lwfs = FW_CONFIG_WAIT;
1280 1.57 mjacob count = 0;
1281 1.57 mjacob while (count < usdelay) {
1282 1.57 mjacob u_int64_t enano;
1283 1.57 mjacob u_int32_t wrk;
1284 1.57 mjacob NANOTIME_T hra, hrb;
1285 1.57 mjacob
1286 1.57 mjacob GET_NANOTIME(&hra);
1287 1.10 mjacob isp_fw_state(isp);
1288 1.23 mjacob if (lwfs != fcp->isp_fwstate) {
1289 1.57 mjacob isp_prt(isp, ISP_LOGINFO, "Firmware State <%s->%s>",
1290 1.57 mjacob isp2100_fw_statename((int)lwfs),
1291 1.28 mjacob isp2100_fw_statename((int)fcp->isp_fwstate));
1292 1.23 mjacob lwfs = fcp->isp_fwstate;
1293 1.23 mjacob }
1294 1.23 mjacob if (fcp->isp_fwstate == FW_READY) {
1295 1.10 mjacob break;
1296 1.23 mjacob }
1297 1.57 mjacob GET_NANOTIME(&hrb);
1298 1.57 mjacob
1299 1.57 mjacob /*
1300 1.57 mjacob * Get the elapsed time in nanoseconds.
1301 1.57 mjacob * Always guaranteed to be non-zero.
1302 1.57 mjacob */
1303 1.57 mjacob enano = NANOTIME_SUB(&hrb, &hra);
1304 1.57 mjacob
1305 1.57 mjacob /*
1306 1.57 mjacob * If the elapsed time is less than 1 millisecond,
1307 1.57 mjacob * delay a period of time up to that millisecond of
1308 1.57 mjacob * waiting.
1309 1.57 mjacob */
1310 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG3, "usec%d: 0x%lx->0x%lx enano %u",
1311 1.57 mjacob count, (long) GET_NANOSEC(&hra), (long) GET_NANOSEC(&hrb),
1312 1.57 mjacob enano);
1313 1.57 mjacob
1314 1.57 mjacob /*
1315 1.57 mjacob * This peculiar code is an attempt to try and avoid
1316 1.57 mjacob * invoking u_int64_t math support functions for some
1317 1.57 mjacob * platforms where linkage is a problem.
1318 1.57 mjacob */
1319 1.57 mjacob if (enano < (1000 * 1000)) {
1320 1.57 mjacob count += 1000;
1321 1.57 mjacob enano = (1000 * 1000) - enano;
1322 1.57 mjacob while (enano > (u_int64_t) 4000000000U) {
1323 1.57 mjacob USEC_DELAY(4000000);
1324 1.57 mjacob enano -= (u_int64_t) 4000000000U;
1325 1.57 mjacob }
1326 1.57 mjacob wrk = enano;
1327 1.57 mjacob USEC_DELAY(wrk/1000);
1328 1.57 mjacob } else {
1329 1.57 mjacob while (enano > (u_int64_t) 4000000000U) {
1330 1.57 mjacob count += 4000000;
1331 1.57 mjacob enano -= (u_int64_t) 4000000000U;
1332 1.57 mjacob }
1333 1.57 mjacob wrk = enano;
1334 1.57 mjacob count += (wrk / 1000);
1335 1.57 mjacob }
1336 1.10 mjacob }
1337 1.10 mjacob
1338 1.10 mjacob /*
1339 1.33 mjacob * If we haven't gone to 'ready' state, return.
1340 1.33 mjacob */
1341 1.33 mjacob if (fcp->isp_fwstate != FW_READY) {
1342 1.33 mjacob return (-1);
1343 1.33 mjacob }
1344 1.34 mjacob
1345 1.33 mjacob /*
1346 1.33 mjacob * Get our Loop ID (if possible). We really need to have it.
1347 1.10 mjacob */
1348 1.33 mjacob mbs.param[0] = MBOX_GET_LOOP_ID;
1349 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
1350 1.33 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1351 1.33 mjacob return (-1);
1352 1.23 mjacob }
1353 1.33 mjacob fcp->isp_loopid = mbs.param[1];
1354 1.49 mjacob if (IS_2200(isp)) {
1355 1.52 he int topo = (int) mbs.param[6];
1356 1.52 he if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB)
1357 1.52 he topo = TOPO_PTP_STUB;
1358 1.52 he fcp->isp_topo = topo;
1359 1.49 mjacob } else {
1360 1.52 he fcp->isp_topo = TOPO_NL_PORT;
1361 1.38 mjacob }
1362 1.52 he fcp->isp_alpa = mbs.param[2];
1363 1.37 mjacob
1364 1.37 mjacob #if defined(ISP2100_FABRIC)
1365 1.38 mjacob fcp->isp_onfabric = 0;
1366 1.52 he if (fcp->isp_topo != TOPO_N_PORT &&
1367 1.52 he isp_getpdb(isp, FL_PORT_ID, &pdb) == 0) {
1368 1.52 he struct lportdb *lp;
1369 1.52 he if (IS_2100(isp)) {
1370 1.52 he fcp->isp_topo = TOPO_FL_PORT;
1371 1.52 he }
1372 1.37 mjacob fcp->isp_portid = mbs.param[2] | (((int)mbs.param[3]) << 16);
1373 1.37 mjacob fcp->isp_onfabric = 1;
1374 1.37 mjacob
1375 1.37 mjacob /*
1376 1.52 he * Save the Fabric controller's port database entry.
1377 1.37 mjacob */
1378 1.52 he lp = &fcp->portdb[FL_PORT_ID];
1379 1.52 he lp->node_wwn =
1380 1.52 he (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
1381 1.52 he (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
1382 1.52 he (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
1383 1.52 he (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
1384 1.52 he (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
1385 1.52 he (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
1386 1.52 he (((u_int64_t)pdb.pdb_nodename[6]) << 8) |
1387 1.52 he (((u_int64_t)pdb.pdb_nodename[7]));
1388 1.52 he lp->port_wwn =
1389 1.52 he (((u_int64_t)pdb.pdb_portname[0]) << 56) |
1390 1.52 he (((u_int64_t)pdb.pdb_portname[1]) << 48) |
1391 1.52 he (((u_int64_t)pdb.pdb_portname[2]) << 40) |
1392 1.52 he (((u_int64_t)pdb.pdb_portname[3]) << 32) |
1393 1.52 he (((u_int64_t)pdb.pdb_portname[4]) << 24) |
1394 1.52 he (((u_int64_t)pdb.pdb_portname[5]) << 16) |
1395 1.52 he (((u_int64_t)pdb.pdb_portname[6]) << 8) |
1396 1.52 he (((u_int64_t)pdb.pdb_portname[7]));
1397 1.52 he lp->roles =
1398 1.52 he (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
1399 1.52 he lp->portid = BITS2WORD(pdb.pdb_portid_bits);
1400 1.52 he lp->loopid = pdb.pdb_loopid;
1401 1.52 he lp->loggedin = lp->valid = 1;
1402 1.52 he #if 0
1403 1.52 he if (isp->isp_rfabric == 0) {
1404 1.52 he isp_i_register_fc4_type(isp);
1405 1.37 mjacob }
1406 1.52 he #endif
1407 1.37 mjacob } else
1408 1.37 mjacob #endif
1409 1.52 he {
1410 1.52 he fcp->isp_portid = mbs.param[2];
1411 1.52 he fcp->isp_onfabric = 0;
1412 1.52 he #if 0
1413 1.52 he isp->isp_rfabric = 0;
1414 1.52 he #endif
1415 1.52 he fcp->portdb[FL_PORT_ID].valid = 0;
1416 1.52 he }
1417 1.52 he
1418 1.57 mjacob isp_prt(isp, ISP_LOGINFO, topology, fcp->isp_loopid, fcp->isp_alpa,
1419 1.57 mjacob fcp->isp_portid, fcp->isp_loopstate, toponames[fcp->isp_topo]);
1420 1.52 he
1421 1.33 mjacob return (0);
1422 1.37 mjacob }
1423 1.37 mjacob
1424 1.57 mjacob static char *
1425 1.57 mjacob isp2100_fw_statename(state)
1426 1.57 mjacob int state;
1427 1.57 mjacob {
1428 1.57 mjacob switch(state) {
1429 1.57 mjacob case FW_CONFIG_WAIT: return "Config Wait";
1430 1.57 mjacob case FW_WAIT_AL_PA: return "Waiting for AL_PA";
1431 1.57 mjacob case FW_WAIT_LOGIN: return "Wait Login";
1432 1.57 mjacob case FW_READY: return "Ready";
1433 1.57 mjacob case FW_LOSS_OF_SYNC: return "Loss Of Sync";
1434 1.57 mjacob case FW_ERROR: return "Error";
1435 1.57 mjacob case FW_REINIT: return "Re-Init";
1436 1.57 mjacob case FW_NON_PART: return "Nonparticipating";
1437 1.57 mjacob default: return "?????";
1438 1.57 mjacob }
1439 1.57 mjacob }
1440 1.33 mjacob
1441 1.37 mjacob static int
1442 1.37 mjacob isp_same_lportdb(a, b)
1443 1.37 mjacob struct lportdb *a, *b;
1444 1.37 mjacob {
1445 1.37 mjacob /*
1446 1.37 mjacob * We decide two lports are the same if they have non-zero and
1447 1.37 mjacob * identical port WWNs and identical loop IDs.
1448 1.37 mjacob */
1449 1.37 mjacob
1450 1.37 mjacob if (a->port_wwn == 0 || a->port_wwn != b->port_wwn ||
1451 1.52 he a->loopid != b->loopid || a->roles != b->roles) {
1452 1.37 mjacob return (0);
1453 1.37 mjacob } else {
1454 1.37 mjacob return (1);
1455 1.37 mjacob }
1456 1.1 cgd }
1457 1.1 cgd
1458 1.1 cgd /*
1459 1.37 mjacob * Synchronize our soft copy of the port database with what the f/w thinks
1460 1.37 mjacob * (with a view toward possibly for a specific target....)
1461 1.37 mjacob */
1462 1.37 mjacob
1463 1.37 mjacob static int
1464 1.37 mjacob isp_pdb_sync(isp, target)
1465 1.37 mjacob struct ispsoftc *isp;
1466 1.37 mjacob int target;
1467 1.37 mjacob {
1468 1.38 mjacob struct lportdb *lp, *tport;
1469 1.37 mjacob fcparam *fcp = isp->isp_param;
1470 1.37 mjacob isp_pdb_t pdb;
1471 1.52 he int loopid, prange, lim;
1472 1.37 mjacob
1473 1.37 mjacob #ifdef ISP2100_FABRIC
1474 1.37 mjacob /*
1475 1.37 mjacob * XXX: If we do this *after* building up our local port database,
1476 1.37 mjacob * XXX: the commands simply don't work.
1477 1.37 mjacob */
1478 1.37 mjacob /*
1479 1.37 mjacob * (Re)discover all fabric devices
1480 1.37 mjacob */
1481 1.37 mjacob if (fcp->isp_onfabric)
1482 1.37 mjacob (void) isp_scan_fabric(isp);
1483 1.37 mjacob #endif
1484 1.38 mjacob
1485 1.38 mjacob
1486 1.52 he switch (fcp->isp_topo) {
1487 1.52 he case TOPO_F_PORT:
1488 1.52 he case TOPO_PTP_STUB:
1489 1.52 he prange = 0;
1490 1.52 he break;
1491 1.52 he case TOPO_N_PORT:
1492 1.52 he prange = 2;
1493 1.52 he break;
1494 1.52 he default:
1495 1.52 he prange = FL_PORT_ID;
1496 1.52 he break;
1497 1.52 he }
1498 1.52 he
1499 1.37 mjacob /*
1500 1.37 mjacob * Run through the local loop ports and get port database info
1501 1.37 mjacob * for each loop ID.
1502 1.37 mjacob *
1503 1.37 mjacob * There's a somewhat unexplained situation where the f/w passes back
1504 1.37 mjacob * the wrong database entity- if that happens, just restart (up to
1505 1.37 mjacob * FL_PORT_ID times).
1506 1.37 mjacob */
1507 1.38 mjacob tport = fcp->tport;
1508 1.46 mjacob
1509 1.43 mjacob /*
1510 1.43 mjacob * make sure the temp port database is clean...
1511 1.43 mjacob */
1512 1.38 mjacob MEMZERO((void *) tport, sizeof (tport));
1513 1.52 he
1514 1.52 he for (lim = loopid = 0; loopid < prange; loopid++) {
1515 1.37 mjacob lp = &tport[loopid];
1516 1.37 mjacob lp->node_wwn = isp_get_portname(isp, loopid, 1);
1517 1.54 mjacob if (fcp->isp_loopstate < LOOP_PDB_RCVD)
1518 1.52 he return (-1);
1519 1.37 mjacob if (lp->node_wwn == 0)
1520 1.37 mjacob continue;
1521 1.37 mjacob lp->port_wwn = isp_get_portname(isp, loopid, 0);
1522 1.54 mjacob if (fcp->isp_loopstate < LOOP_PDB_RCVD)
1523 1.52 he return (-1);
1524 1.37 mjacob if (lp->port_wwn == 0) {
1525 1.37 mjacob lp->node_wwn = 0;
1526 1.37 mjacob continue;
1527 1.37 mjacob }
1528 1.38 mjacob
1529 1.37 mjacob /*
1530 1.37 mjacob * Get an entry....
1531 1.37 mjacob */
1532 1.37 mjacob if (isp_getpdb(isp, loopid, &pdb) != 0) {
1533 1.54 mjacob if (fcp->isp_loopstate < LOOP_PDB_RCVD)
1534 1.52 he return (-1);
1535 1.37 mjacob continue;
1536 1.37 mjacob }
1537 1.38 mjacob
1538 1.54 mjacob if (fcp->isp_loopstate < LOOP_PDB_RCVD)
1539 1.52 he return (-1);
1540 1.52 he
1541 1.37 mjacob /*
1542 1.37 mjacob * If the returned database element doesn't match what we
1543 1.37 mjacob * asked for, restart the process entirely (up to a point...).
1544 1.37 mjacob */
1545 1.37 mjacob if (pdb.pdb_loopid != loopid) {
1546 1.37 mjacob loopid = 0;
1547 1.37 mjacob if (lim++ < FL_PORT_ID) {
1548 1.37 mjacob continue;
1549 1.37 mjacob }
1550 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
1551 1.57 mjacob "giving up on synchronizing the port database");
1552 1.37 mjacob return (-1);
1553 1.37 mjacob }
1554 1.38 mjacob
1555 1.37 mjacob /*
1556 1.37 mjacob * Save the pertinent info locally.
1557 1.37 mjacob */
1558 1.37 mjacob lp->node_wwn =
1559 1.37 mjacob (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
1560 1.37 mjacob (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
1561 1.37 mjacob (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
1562 1.37 mjacob (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
1563 1.37 mjacob (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
1564 1.37 mjacob (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
1565 1.37 mjacob (((u_int64_t)pdb.pdb_nodename[6]) << 8) |
1566 1.37 mjacob (((u_int64_t)pdb.pdb_nodename[7]));
1567 1.37 mjacob lp->port_wwn =
1568 1.37 mjacob (((u_int64_t)pdb.pdb_portname[0]) << 56) |
1569 1.37 mjacob (((u_int64_t)pdb.pdb_portname[1]) << 48) |
1570 1.37 mjacob (((u_int64_t)pdb.pdb_portname[2]) << 40) |
1571 1.37 mjacob (((u_int64_t)pdb.pdb_portname[3]) << 32) |
1572 1.37 mjacob (((u_int64_t)pdb.pdb_portname[4]) << 24) |
1573 1.37 mjacob (((u_int64_t)pdb.pdb_portname[5]) << 16) |
1574 1.37 mjacob (((u_int64_t)pdb.pdb_portname[6]) << 8) |
1575 1.37 mjacob (((u_int64_t)pdb.pdb_portname[7]));
1576 1.37 mjacob lp->roles =
1577 1.37 mjacob (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
1578 1.37 mjacob lp->portid = BITS2WORD(pdb.pdb_portid_bits);
1579 1.37 mjacob lp->loopid = pdb.pdb_loopid;
1580 1.37 mjacob /*
1581 1.37 mjacob * Do a quick check to see whether this matches the saved port
1582 1.37 mjacob * database for the same loopid. We do this here to save
1583 1.37 mjacob * searching later (if possible). Note that this fails over
1584 1.37 mjacob * time as things shuffle on the loop- we get the current
1585 1.37 mjacob * loop state (where loop id as an index matches loop id in
1586 1.37 mjacob * use) and then compare it to our saved database which
1587 1.37 mjacob * never shifts.
1588 1.37 mjacob */
1589 1.46 mjacob if (target >= 0 && isp_same_lportdb(lp, &fcp->portdb[target])) {
1590 1.37 mjacob lp->valid = 1;
1591 1.37 mjacob }
1592 1.37 mjacob }
1593 1.37 mjacob
1594 1.37 mjacob /*
1595 1.37 mjacob * If we get this far, we've settled our differences with the f/w
1596 1.37 mjacob * and we can say that the loop state is ready.
1597 1.37 mjacob */
1598 1.37 mjacob fcp->isp_loopstate = LOOP_READY;
1599 1.37 mjacob
1600 1.37 mjacob /*
1601 1.38 mjacob * Mark all of the permanent local loop database entries as invalid.
1602 1.38 mjacob */
1603 1.38 mjacob for (loopid = 0; loopid < FL_PORT_ID; loopid++) {
1604 1.38 mjacob fcp->portdb[loopid].valid = 0;
1605 1.38 mjacob }
1606 1.38 mjacob
1607 1.38 mjacob /*
1608 1.37 mjacob * Now merge our local copy of the port database into our saved copy.
1609 1.37 mjacob * Notify the outer layers of new devices arriving.
1610 1.37 mjacob */
1611 1.52 he for (loopid = 0; loopid < prange; loopid++) {
1612 1.37 mjacob int i;
1613 1.37 mjacob
1614 1.37 mjacob /*
1615 1.37 mjacob * If we don't have a non-zero Port WWN, we're not here.
1616 1.37 mjacob */
1617 1.37 mjacob if (tport[loopid].port_wwn == 0) {
1618 1.37 mjacob continue;
1619 1.37 mjacob }
1620 1.37 mjacob
1621 1.37 mjacob /*
1622 1.37 mjacob * If we've already marked our tmp copy as valid,
1623 1.37 mjacob * this means that we've decided that it's the
1624 1.38 mjacob * same as our saved data base. This didn't include
1625 1.38 mjacob * the 'valid' marking so we have set that here.
1626 1.37 mjacob */
1627 1.37 mjacob if (tport[loopid].valid) {
1628 1.37 mjacob fcp->portdb[loopid].valid = 1;
1629 1.37 mjacob continue;
1630 1.37 mjacob }
1631 1.37 mjacob
1632 1.37 mjacob /*
1633 1.37 mjacob * For the purposes of deciding whether this is the
1634 1.37 mjacob * 'same' device or not, we only search for an identical
1635 1.37 mjacob * Port WWN. Node WWNs may or may not be the same as
1636 1.37 mjacob * the Port WWN, and there may be multiple different
1637 1.37 mjacob * Port WWNs with the same Node WWN. It would be chaos
1638 1.37 mjacob * to have multiple identical Port WWNs, so we don't
1639 1.37 mjacob * allow that.
1640 1.37 mjacob */
1641 1.37 mjacob
1642 1.37 mjacob for (i = 0; i < FL_PORT_ID; i++) {
1643 1.37 mjacob int j;
1644 1.37 mjacob if (fcp->portdb[i].port_wwn == 0)
1645 1.37 mjacob continue;
1646 1.37 mjacob if (fcp->portdb[i].port_wwn != tport[loopid].port_wwn)
1647 1.37 mjacob continue;
1648 1.37 mjacob /*
1649 1.37 mjacob * We found this WWN elsewhere- it's changed
1650 1.37 mjacob * loopids then. We don't change it's actual
1651 1.37 mjacob * position in our cached port database- we
1652 1.37 mjacob * just change the actual loop ID we'd use.
1653 1.37 mjacob */
1654 1.37 mjacob if (fcp->portdb[i].loopid != loopid) {
1655 1.57 mjacob isp_prt(isp, ISP_LOGINFO, portshift, i,
1656 1.57 mjacob fcp->portdb[i].loopid,
1657 1.38 mjacob fcp->portdb[i].portid, loopid,
1658 1.38 mjacob tport[loopid].portid);
1659 1.37 mjacob }
1660 1.38 mjacob fcp->portdb[i].portid = tport[loopid].portid;
1661 1.37 mjacob fcp->portdb[i].loopid = loopid;
1662 1.37 mjacob fcp->portdb[i].valid = 1;
1663 1.52 he fcp->portdb[i].roles = tport[loopid].roles;
1664 1.37 mjacob
1665 1.37 mjacob /*
1666 1.37 mjacob * Now make sure this Port WWN doesn't exist elsewhere
1667 1.37 mjacob * in the port database.
1668 1.37 mjacob */
1669 1.37 mjacob for (j = i+1; j < FL_PORT_ID; j++) {
1670 1.37 mjacob if (fcp->portdb[i].port_wwn !=
1671 1.37 mjacob fcp->portdb[j].port_wwn) {
1672 1.37 mjacob continue;
1673 1.37 mjacob }
1674 1.57 mjacob isp_prt(isp, ISP_LOGWARN, portdup, j, i);
1675 1.37 mjacob /*
1676 1.37 mjacob * Invalidate the 'old' *and* 'new' ones.
1677 1.37 mjacob * This is really harsh and not quite right,
1678 1.37 mjacob * but if this happens, we really don't know
1679 1.37 mjacob * who is what at this point.
1680 1.37 mjacob */
1681 1.37 mjacob fcp->portdb[i].valid = 0;
1682 1.37 mjacob fcp->portdb[j].valid = 0;
1683 1.37 mjacob }
1684 1.37 mjacob break;
1685 1.37 mjacob }
1686 1.37 mjacob
1687 1.37 mjacob /*
1688 1.37 mjacob * If we didn't traverse the entire port database,
1689 1.37 mjacob * then we found (and remapped) an existing entry.
1690 1.37 mjacob * No need to notify anyone- go for the next one.
1691 1.37 mjacob */
1692 1.37 mjacob if (i < FL_PORT_ID) {
1693 1.37 mjacob continue;
1694 1.37 mjacob }
1695 1.37 mjacob
1696 1.37 mjacob /*
1697 1.37 mjacob * We've not found this Port WWN anywhere. It's a new entry.
1698 1.37 mjacob * See if we can leave it where it is (with target == loopid).
1699 1.37 mjacob */
1700 1.37 mjacob if (fcp->portdb[loopid].port_wwn != 0) {
1701 1.37 mjacob for (lim = 0; lim < FL_PORT_ID; lim++) {
1702 1.37 mjacob if (fcp->portdb[lim].port_wwn == 0)
1703 1.37 mjacob break;
1704 1.37 mjacob }
1705 1.37 mjacob /* "Cannot Happen" */
1706 1.37 mjacob if (lim == FL_PORT_ID) {
1707 1.57 mjacob isp_prt(isp, ISP_LOGWARN, "Remap Overflow");
1708 1.37 mjacob continue;
1709 1.37 mjacob }
1710 1.37 mjacob i = lim;
1711 1.37 mjacob } else {
1712 1.37 mjacob i = loopid;
1713 1.37 mjacob }
1714 1.37 mjacob
1715 1.37 mjacob /*
1716 1.37 mjacob * NB: The actual loopid we use here is loopid- we may
1717 1.37 mjacob * in fact be at a completely different index (target).
1718 1.37 mjacob */
1719 1.37 mjacob fcp->portdb[i].loopid = loopid;
1720 1.37 mjacob fcp->portdb[i].port_wwn = tport[loopid].port_wwn;
1721 1.37 mjacob fcp->portdb[i].node_wwn = tport[loopid].node_wwn;
1722 1.37 mjacob fcp->portdb[i].roles = tport[loopid].roles;
1723 1.37 mjacob fcp->portdb[i].portid = tport[loopid].portid;
1724 1.37 mjacob fcp->portdb[i].valid = 1;
1725 1.37 mjacob
1726 1.37 mjacob /*
1727 1.37 mjacob * Tell the outside world we've arrived.
1728 1.37 mjacob */
1729 1.37 mjacob (void) isp_async(isp, ISPASYNC_PDB_CHANGED, &i);
1730 1.37 mjacob }
1731 1.37 mjacob
1732 1.37 mjacob /*
1733 1.37 mjacob * Now find all previously used targets that are now invalid and
1734 1.37 mjacob * notify the outer layers that they're gone.
1735 1.37 mjacob */
1736 1.52 he for (lp = fcp->portdb; lp < &fcp->portdb[prange]; lp++) {
1737 1.37 mjacob if (lp->valid || lp->port_wwn == 0)
1738 1.37 mjacob continue;
1739 1.37 mjacob
1740 1.37 mjacob /*
1741 1.43 mjacob * Tell the outside world we've gone away.
1742 1.37 mjacob */
1743 1.37 mjacob loopid = lp - fcp->portdb;
1744 1.37 mjacob (void) isp_async(isp, ISPASYNC_PDB_CHANGED, &loopid);
1745 1.37 mjacob MEMZERO((void *) lp, sizeof (*lp));
1746 1.37 mjacob }
1747 1.37 mjacob
1748 1.37 mjacob #ifdef ISP2100_FABRIC
1749 1.37 mjacob /*
1750 1.37 mjacob * Now log in any fabric devices
1751 1.37 mjacob */
1752 1.52 he for (lp = &fcp->portdb[FC_SNS_ID+1];
1753 1.37 mjacob lp < &fcp->portdb[MAX_FC_TARG]; lp++) {
1754 1.50 mjacob u_int32_t portid;
1755 1.37 mjacob mbreg_t mbs;
1756 1.37 mjacob
1757 1.37 mjacob /*
1758 1.52 he * Anything here?
1759 1.37 mjacob */
1760 1.37 mjacob if (lp->port_wwn == 0)
1761 1.37 mjacob continue;
1762 1.50 mjacob
1763 1.37 mjacob /*
1764 1.37 mjacob * Don't try to log into yourself.
1765 1.37 mjacob */
1766 1.50 mjacob if ((portid = lp->portid) == fcp->isp_portid)
1767 1.37 mjacob continue;
1768 1.37 mjacob
1769 1.52 he
1770 1.52 he /*
1771 1.52 he * If we'd been logged in- see if we still are and we haven't
1772 1.52 he * changed. If so, no need to log ourselves out, etc..
1773 1.52 he */
1774 1.52 he if (lp->loggedin &&
1775 1.52 he isp_getpdb(isp, lp->loopid, &pdb) == 0) {
1776 1.52 he int nrole;
1777 1.52 he u_int64_t nwwnn, nwwpn;
1778 1.52 he nwwnn =
1779 1.52 he (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
1780 1.52 he (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
1781 1.52 he (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
1782 1.52 he (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
1783 1.52 he (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
1784 1.52 he (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
1785 1.52 he (((u_int64_t)pdb.pdb_nodename[6]) << 8) |
1786 1.52 he (((u_int64_t)pdb.pdb_nodename[7]));
1787 1.52 he nwwpn =
1788 1.52 he (((u_int64_t)pdb.pdb_portname[0]) << 56) |
1789 1.52 he (((u_int64_t)pdb.pdb_portname[1]) << 48) |
1790 1.52 he (((u_int64_t)pdb.pdb_portname[2]) << 40) |
1791 1.52 he (((u_int64_t)pdb.pdb_portname[3]) << 32) |
1792 1.52 he (((u_int64_t)pdb.pdb_portname[4]) << 24) |
1793 1.52 he (((u_int64_t)pdb.pdb_portname[5]) << 16) |
1794 1.52 he (((u_int64_t)pdb.pdb_portname[6]) << 8) |
1795 1.52 he (((u_int64_t)pdb.pdb_portname[7]));
1796 1.52 he nrole = (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >>
1797 1.52 he SVC3_ROLE_SHIFT;
1798 1.52 he if (pdb.pdb_loopid == lp->loopid && lp->portid ==
1799 1.52 he (u_int32_t) BITS2WORD(pdb.pdb_portid_bits) &&
1800 1.52 he nwwnn == lp->node_wwn && nwwpn == lp->port_wwn &&
1801 1.52 he lp->roles == nrole) {
1802 1.52 he lp->loggedin = lp->valid = 1;
1803 1.57 mjacob isp_prt(isp, ISP_LOGINFO, lretained,
1804 1.57 mjacob (int) (lp - fcp->portdb),
1805 1.57 mjacob (int) lp->loopid, lp->portid);
1806 1.52 he continue;
1807 1.52 he }
1808 1.52 he }
1809 1.52 he
1810 1.37 mjacob /*
1811 1.50 mjacob * Force a logout if we were logged in.
1812 1.37 mjacob */
1813 1.52 he if (lp->loggedin) {
1814 1.50 mjacob mbs.param[0] = MBOX_FABRIC_LOGOUT;
1815 1.50 mjacob mbs.param[1] = lp->loopid << 8;
1816 1.50 mjacob mbs.param[2] = 0;
1817 1.50 mjacob mbs.param[3] = 0;
1818 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGNONE);
1819 1.52 he lp->loggedin = 0;
1820 1.57 mjacob isp_prt(isp, ISP_LOGINFO, plogout,
1821 1.57 mjacob (int) (lp - fcp->portdb), lp->loopid, lp->portid);
1822 1.50 mjacob }
1823 1.37 mjacob
1824 1.37 mjacob /*
1825 1.37 mjacob * And log in....
1826 1.37 mjacob */
1827 1.50 mjacob loopid = lp - fcp->portdb;
1828 1.50 mjacob lp->loopid = 0;
1829 1.50 mjacob do {
1830 1.50 mjacob mbs.param[0] = MBOX_FABRIC_LOGIN;
1831 1.50 mjacob mbs.param[1] = loopid << 8;
1832 1.52 he mbs.param[2] = portid >> 16;
1833 1.52 he mbs.param[3] = portid & 0xffff;
1834 1.50 mjacob if (IS_2200(isp)) {
1835 1.50 mjacob /* only issue a PLOGI if not logged in */
1836 1.50 mjacob mbs.param[1] |= 0x1;
1837 1.50 mjacob }
1838 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL & ~(MBOX_LOOP_ID_USED |
1839 1.57 mjacob MBOX_PORT_ID_USED | MBOX_COMMAND_ERROR));
1840 1.50 mjacob switch (mbs.param[0]) {
1841 1.50 mjacob case MBOX_LOOP_ID_USED:
1842 1.50 mjacob /*
1843 1.50 mjacob * Try the next available loop id.
1844 1.50 mjacob */
1845 1.50 mjacob loopid++;
1846 1.43 mjacob break;
1847 1.50 mjacob case MBOX_PORT_ID_USED:
1848 1.50 mjacob /*
1849 1.50 mjacob * This port is already logged in.
1850 1.52 he * Snaffle the loop id it's using if it's
1851 1.52 he * nonzero, otherwise we're hosed.
1852 1.50 mjacob */
1853 1.52 he if (mbs.param[1] != 0) {
1854 1.52 he loopid = mbs.param[1];
1855 1.57 mjacob isp_prt(isp, ISP_LOGINFO, retained,
1856 1.57 mjacob loopid, (int) (lp - fcp->portdb),
1857 1.57 mjacob lp->portid);
1858 1.52 he } else {
1859 1.52 he loopid = MAX_FC_TARG;
1860 1.52 he break;
1861 1.50 mjacob }
1862 1.50 mjacob /* FALLTHROUGH */
1863 1.50 mjacob case MBOX_COMMAND_COMPLETE:
1864 1.52 he lp->loggedin = 1;
1865 1.50 mjacob lp->loopid = loopid;
1866 1.43 mjacob break;
1867 1.50 mjacob case MBOX_COMMAND_ERROR:
1868 1.57 mjacob isp_prt(isp, ISP_LOGINFO, plogierr,
1869 1.57 mjacob portid, mbs.param[1]);
1870 1.50 mjacob /* FALLTHROUGH */
1871 1.50 mjacob case MBOX_ALL_IDS_USED: /* We're outta IDs */
1872 1.43 mjacob default:
1873 1.52 he loopid = MAX_FC_TARG;
1874 1.43 mjacob break;
1875 1.38 mjacob }
1876 1.52 he } while (lp->loopid == 0 && loopid < MAX_FC_TARG);
1877 1.52 he
1878 1.52 he /*
1879 1.52 he * If we get here and we haven't set a Loop ID,
1880 1.52 he * we failed to log into this device.
1881 1.52 he */
1882 1.52 he
1883 1.52 he if (lp->loopid == 0) {
1884 1.43 mjacob continue;
1885 1.52 he }
1886 1.43 mjacob
1887 1.52 he /*
1888 1.52 he * Make sure we can get the approriate port information.
1889 1.52 he */
1890 1.50 mjacob if (isp_getpdb(isp, lp->loopid, &pdb) != 0) {
1891 1.57 mjacob isp_prt(isp, ISP_LOGWARN, nopdb, lp->portid);
1892 1.52 he goto dump_em;
1893 1.43 mjacob }
1894 1.52 he
1895 1.43 mjacob if (pdb.pdb_loopid != lp->loopid) {
1896 1.57 mjacob isp_prt(isp, ISP_LOGWARN, pdbmfail1,
1897 1.57 mjacob lp->portid, pdb.pdb_loopid);
1898 1.52 he goto dump_em;
1899 1.52 he }
1900 1.52 he
1901 1.52 he if (lp->portid != (u_int32_t) BITS2WORD(pdb.pdb_portid_bits)) {
1902 1.57 mjacob isp_prt(isp, ISP_LOGWARN, pdbmfail2,
1903 1.57 mjacob lp->portid, BITS2WORD(pdb.pdb_portid_bits));
1904 1.52 he goto dump_em;
1905 1.43 mjacob }
1906 1.52 he
1907 1.43 mjacob lp->roles =
1908 1.43 mjacob (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
1909 1.43 mjacob lp->node_wwn =
1910 1.43 mjacob (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
1911 1.43 mjacob (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
1912 1.43 mjacob (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
1913 1.43 mjacob (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
1914 1.43 mjacob (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
1915 1.43 mjacob (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
1916 1.43 mjacob (((u_int64_t)pdb.pdb_nodename[6]) << 8) |
1917 1.43 mjacob (((u_int64_t)pdb.pdb_nodename[7]));
1918 1.43 mjacob lp->port_wwn =
1919 1.43 mjacob (((u_int64_t)pdb.pdb_portname[0]) << 56) |
1920 1.43 mjacob (((u_int64_t)pdb.pdb_portname[1]) << 48) |
1921 1.43 mjacob (((u_int64_t)pdb.pdb_portname[2]) << 40) |
1922 1.43 mjacob (((u_int64_t)pdb.pdb_portname[3]) << 32) |
1923 1.43 mjacob (((u_int64_t)pdb.pdb_portname[4]) << 24) |
1924 1.43 mjacob (((u_int64_t)pdb.pdb_portname[5]) << 16) |
1925 1.43 mjacob (((u_int64_t)pdb.pdb_portname[6]) << 8) |
1926 1.43 mjacob (((u_int64_t)pdb.pdb_portname[7]));
1927 1.43 mjacob /*
1928 1.43 mjacob * Check to make sure this all makes sense.
1929 1.43 mjacob */
1930 1.43 mjacob if (lp->node_wwn && lp->port_wwn) {
1931 1.52 he lp->valid = 1;
1932 1.50 mjacob loopid = lp - fcp->portdb;
1933 1.43 mjacob (void) isp_async(isp, ISPASYNC_PDB_CHANGED, &loopid);
1934 1.43 mjacob continue;
1935 1.37 mjacob }
1936 1.52 he dump_em:
1937 1.52 he lp->valid = 0;
1938 1.57 mjacob isp_prt(isp, ISP_LOGINFO,
1939 1.57 mjacob ldumped, loopid, lp->loopid, lp->portid);
1940 1.43 mjacob mbs.param[0] = MBOX_FABRIC_LOGOUT;
1941 1.43 mjacob mbs.param[1] = lp->loopid << 8;
1942 1.43 mjacob mbs.param[2] = 0;
1943 1.43 mjacob mbs.param[3] = 0;
1944 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGNONE);
1945 1.37 mjacob }
1946 1.37 mjacob #endif
1947 1.46 mjacob /*
1948 1.46 mjacob * If we get here, we've for sure seen not only a valid loop
1949 1.46 mjacob * but know what is or isn't on it, so mark this for usage
1950 1.57 mjacob * in isp_start.
1951 1.46 mjacob */
1952 1.46 mjacob fcp->loop_seen_once = 1;
1953 1.37 mjacob return (0);
1954 1.37 mjacob }
1955 1.37 mjacob
1956 1.37 mjacob #ifdef ISP2100_FABRIC
1957 1.37 mjacob static int
1958 1.37 mjacob isp_scan_fabric(isp)
1959 1.37 mjacob struct ispsoftc *isp;
1960 1.37 mjacob {
1961 1.37 mjacob fcparam *fcp = isp->isp_param;
1962 1.37 mjacob u_int32_t portid, first_nz_portid;
1963 1.37 mjacob sns_screq_t *reqp;
1964 1.37 mjacob sns_scrsp_t *resp;
1965 1.37 mjacob mbreg_t mbs;
1966 1.37 mjacob int hicap;
1967 1.37 mjacob
1968 1.37 mjacob reqp = (sns_screq_t *) fcp->isp_scratch;
1969 1.37 mjacob resp = (sns_scrsp_t *) (&((char *)fcp->isp_scratch)[0x100]);
1970 1.37 mjacob first_nz_portid = portid = fcp->isp_portid;
1971 1.37 mjacob
1972 1.37 mjacob for (hicap = 0; hicap < 1024; hicap++) {
1973 1.37 mjacob MEMZERO((void *) reqp, SNS_GAN_REQ_SIZE);
1974 1.37 mjacob reqp->snscb_rblen = SNS_GAN_RESP_SIZE >> 1;
1975 1.37 mjacob reqp->snscb_addr[RQRSP_ADDR0015] =
1976 1.37 mjacob DMA_LSW(fcp->isp_scdma + 0x100);
1977 1.37 mjacob reqp->snscb_addr[RQRSP_ADDR1631] =
1978 1.37 mjacob DMA_MSW(fcp->isp_scdma + 0x100);
1979 1.37 mjacob reqp->snscb_sblen = 6;
1980 1.37 mjacob reqp->snscb_data[0] = SNS_GAN;
1981 1.37 mjacob reqp->snscb_data[4] = portid & 0xffff;
1982 1.37 mjacob reqp->snscb_data[5] = (portid >> 16) & 0xff;
1983 1.38 mjacob ISP_SWIZZLE_SNS_REQ(isp, reqp);
1984 1.37 mjacob mbs.param[0] = MBOX_SEND_SNS;
1985 1.37 mjacob mbs.param[1] = SNS_GAN_REQ_SIZE >> 1;
1986 1.37 mjacob mbs.param[2] = DMA_MSW(fcp->isp_scdma);
1987 1.37 mjacob mbs.param[3] = DMA_LSW(fcp->isp_scdma);
1988 1.37 mjacob mbs.param[6] = 0;
1989 1.37 mjacob mbs.param[7] = 0;
1990 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
1991 1.37 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1992 1.37 mjacob return (-1);
1993 1.37 mjacob }
1994 1.38 mjacob ISP_UNSWIZZLE_SNS_RSP(isp, resp, SNS_GAN_RESP_SIZE >> 1);
1995 1.37 mjacob portid = (((u_int32_t) resp->snscb_port_id[0]) << 16) |
1996 1.37 mjacob (((u_int32_t) resp->snscb_port_id[1]) << 8) |
1997 1.37 mjacob (((u_int32_t) resp->snscb_port_id[2]));
1998 1.37 mjacob if (isp_async(isp, ISPASYNC_FABRIC_DEV, resp)) {
1999 1.37 mjacob return (-1);
2000 1.37 mjacob }
2001 1.37 mjacob if (first_nz_portid == 0 && portid) {
2002 1.37 mjacob first_nz_portid = portid;
2003 1.37 mjacob }
2004 1.37 mjacob if (first_nz_portid == portid) {
2005 1.37 mjacob return (0);
2006 1.37 mjacob }
2007 1.37 mjacob }
2008 1.37 mjacob /*
2009 1.37 mjacob * We either have a broken name server or a huge fabric if we get here.
2010 1.37 mjacob */
2011 1.37 mjacob return (0);
2012 1.37 mjacob }
2013 1.37 mjacob #endif
2014 1.37 mjacob /*
2015 1.23 mjacob * Start a command. Locking is assumed done in the caller.
2016 1.1 cgd */
2017 1.23 mjacob
2018 1.57 mjacob int
2019 1.57 mjacob isp_start(xs)
2020 1.57 mjacob XS_T *xs;
2021 1.1 cgd {
2022 1.1 cgd struct ispsoftc *isp;
2023 1.43 mjacob u_int16_t iptr, optr;
2024 1.10 mjacob union {
2025 1.10 mjacob ispreq_t *_reqp;
2026 1.10 mjacob ispreqt2_t *_t2reqp;
2027 1.10 mjacob } _u;
2028 1.10 mjacob #define reqp _u._reqp
2029 1.10 mjacob #define t2reqp _u._t2reqp
2030 1.16 mjacob #define UZSIZE max(sizeof (ispreq_t), sizeof (ispreqt2_t))
2031 1.38 mjacob int target, i;
2032 1.1 cgd
2033 1.23 mjacob XS_INITERR(xs);
2034 1.23 mjacob isp = XS_ISP(xs);
2035 1.1 cgd
2036 1.24 mjacob if (isp->isp_state != ISP_RUNSTATE) {
2037 1.57 mjacob isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
2038 1.24 mjacob XS_SETERR(xs, HBA_BOTCH);
2039 1.24 mjacob return (CMD_COMPLETE);
2040 1.24 mjacob }
2041 1.24 mjacob
2042 1.25 mjacob /*
2043 1.50 mjacob * Check command CDB length, etc.. We really are limited to 16 bytes
2044 1.50 mjacob * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
2045 1.50 mjacob * but probably only if we're running fairly new firmware (we'll
2046 1.50 mjacob * let the old f/w choke on an extended command queue entry).
2047 1.25 mjacob */
2048 1.33 mjacob
2049 1.50 mjacob if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
2050 1.57 mjacob isp_prt(isp, ISP_LOGERR,
2051 1.57 mjacob "unsupported cdb length (%d, CDB[0]=0x%x)",
2052 1.57 mjacob XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
2053 1.25 mjacob XS_SETERR(xs, HBA_BOTCH);
2054 1.25 mjacob return (CMD_COMPLETE);
2055 1.25 mjacob }
2056 1.25 mjacob
2057 1.25 mjacob /*
2058 1.33 mjacob * Check to see whether we have good firmware state still or
2059 1.33 mjacob * need to refresh our port database for this target.
2060 1.33 mjacob */
2061 1.37 mjacob target = XS_TGT(xs);
2062 1.33 mjacob if (IS_FC(isp)) {
2063 1.33 mjacob fcparam *fcp = isp->isp_param;
2064 1.37 mjacob struct lportdb *lp;
2065 1.37 mjacob #if defined(ISP2100_FABRIC)
2066 1.52 he /*
2067 1.52 he * If we're not on a Fabric, we can't have a target
2068 1.52 he * above FL_PORT_ID-1. If we're on a fabric and
2069 1.52 he * connected as an F-port, we can't have a target
2070 1.52 he * less than FC_SNS_ID+1.
2071 1.52 he */
2072 1.52 he if (fcp->isp_onfabric == 0) {
2073 1.52 he if (target >= FL_PORT_ID) {
2074 1.52 he XS_SETERR(xs, HBA_SELTIMEOUT);
2075 1.52 he return (CMD_COMPLETE);
2076 1.52 he }
2077 1.52 he } else {
2078 1.52 he if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
2079 1.52 he XS_SETERR(xs, HBA_SELTIMEOUT);
2080 1.52 he return (CMD_COMPLETE);
2081 1.52 he }
2082 1.52 he if (fcp->isp_topo == TOPO_F_PORT &&
2083 1.52 he target < FL_PORT_ID) {
2084 1.37 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
2085 1.37 mjacob return (CMD_COMPLETE);
2086 1.37 mjacob }
2087 1.37 mjacob }
2088 1.37 mjacob #endif
2089 1.33 mjacob /*
2090 1.37 mjacob * Check for f/w being in ready state. If the f/w
2091 1.37 mjacob * isn't in ready state, then we don't know our
2092 1.37 mjacob * loop ID and the f/w hasn't completed logging
2093 1.37 mjacob * into all targets on the loop. If this is the
2094 1.37 mjacob * case, then bounce the command. We pretend this is
2095 1.37 mjacob * a SELECTION TIMEOUT error if we've never gone to
2096 1.37 mjacob * FW_READY state at all- in this case we may not
2097 1.37 mjacob * be hooked to a loop at all and we shouldn't hang
2098 1.37 mjacob * the machine for this. Otherwise, defer this command
2099 1.37 mjacob * until later.
2100 1.33 mjacob */
2101 1.33 mjacob if (fcp->isp_fwstate != FW_READY) {
2102 1.57 mjacob /*
2103 1.57 mjacob * Give ourselves at most a 250ms delay.
2104 1.57 mjacob */
2105 1.57 mjacob if (isp_fclink_test(isp, 250000)) {
2106 1.33 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
2107 1.37 mjacob if (fcp->loop_seen_once) {
2108 1.38 mjacob return (CMD_RQLATER);
2109 1.37 mjacob } else {
2110 1.37 mjacob return (CMD_COMPLETE);
2111 1.37 mjacob }
2112 1.37 mjacob }
2113 1.37 mjacob }
2114 1.37 mjacob
2115 1.37 mjacob /*
2116 1.37 mjacob * If our loop state is such that we haven't yet received
2117 1.37 mjacob * a "Port Database Changed" notification (after a LIP or
2118 1.37 mjacob * a Loop Reset or firmware initialization), then defer
2119 1.46 mjacob * sending commands for a little while, but only if we've
2120 1.46 mjacob * seen a valid loop at one point (otherwise we can get
2121 1.46 mjacob * stuck at initialization time).
2122 1.37 mjacob */
2123 1.37 mjacob if (fcp->isp_loopstate < LOOP_PDB_RCVD) {
2124 1.37 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
2125 1.46 mjacob if (fcp->loop_seen_once) {
2126 1.46 mjacob return (CMD_RQLATER);
2127 1.46 mjacob } else {
2128 1.46 mjacob return (CMD_COMPLETE);
2129 1.46 mjacob }
2130 1.37 mjacob }
2131 1.37 mjacob
2132 1.37 mjacob /*
2133 1.37 mjacob * If our loop state is now such that we've just now
2134 1.37 mjacob * received a Port Database Change notification, then
2135 1.43 mjacob * we have to go off and (re)synchronize our port
2136 1.43 mjacob * database.
2137 1.37 mjacob */
2138 1.37 mjacob if (fcp->isp_loopstate == LOOP_PDB_RCVD) {
2139 1.37 mjacob if (isp_pdb_sync(isp, target)) {
2140 1.37 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
2141 1.33 mjacob return (CMD_COMPLETE);
2142 1.33 mjacob }
2143 1.33 mjacob }
2144 1.37 mjacob
2145 1.33 mjacob /*
2146 1.57 mjacob * XXX: Here's were we would cancel any loop_dead flag
2147 1.57 mjacob * XXX: also cancel in dead_loop timeout that's running
2148 1.57 mjacob */
2149 1.57 mjacob
2150 1.57 mjacob /*
2151 1.37 mjacob * Now check whether we should even think about pursuing this.
2152 1.33 mjacob */
2153 1.37 mjacob lp = &fcp->portdb[target];
2154 1.37 mjacob if (lp->valid == 0) {
2155 1.37 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
2156 1.37 mjacob return (CMD_COMPLETE);
2157 1.37 mjacob }
2158 1.37 mjacob if ((lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT)) == 0) {
2159 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG2,
2160 1.57 mjacob "Target %d does not have target service", target);
2161 1.37 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
2162 1.37 mjacob return (CMD_COMPLETE);
2163 1.33 mjacob }
2164 1.37 mjacob /*
2165 1.37 mjacob * Now turn target into what the actual loop ID is.
2166 1.37 mjacob */
2167 1.37 mjacob target = lp->loopid;
2168 1.33 mjacob }
2169 1.33 mjacob
2170 1.33 mjacob /*
2171 1.33 mjacob * Next check to see if any HBA or Device
2172 1.25 mjacob * parameters need to be updated.
2173 1.25 mjacob */
2174 1.36 mjacob if (isp->isp_update != 0) {
2175 1.25 mjacob isp_update(isp);
2176 1.10 mjacob }
2177 1.25 mjacob
2178 1.43 mjacob if (isp_getrqentry(isp, &iptr, &optr, (void **) &reqp)) {
2179 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow");
2180 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
2181 1.23 mjacob return (CMD_EAGAIN);
2182 1.1 cgd }
2183 1.13 mjacob
2184 1.36 mjacob /*
2185 1.36 mjacob * Now see if we need to synchronize the ISP with respect to anything.
2186 1.36 mjacob * We do dual duty here (cough) for synchronizing for busses other
2187 1.36 mjacob * than which we got here to send a command to.
2188 1.36 mjacob */
2189 1.1 cgd if (isp->isp_sendmarker) {
2190 1.44 mjacob u_int8_t n = (IS_DUALBUS(isp)? 2: 1);
2191 1.27 mjacob /*
2192 1.36 mjacob * Check ports to send markers for...
2193 1.27 mjacob */
2194 1.36 mjacob for (i = 0; i < n; i++) {
2195 1.36 mjacob if ((isp->isp_sendmarker & (1 << i)) == 0) {
2196 1.36 mjacob continue;
2197 1.36 mjacob }
2198 1.36 mjacob MEMZERO((void *) reqp, sizeof (*reqp));
2199 1.36 mjacob reqp->req_header.rqs_entry_count = 1;
2200 1.36 mjacob reqp->req_header.rqs_entry_type = RQSTYPE_MARKER;
2201 1.36 mjacob reqp->req_modifier = SYNC_ALL;
2202 1.38 mjacob reqp->req_target = i << 7; /* insert bus number */
2203 1.38 mjacob ISP_SWIZZLE_REQUEST(isp, reqp);
2204 1.43 mjacob ISP_ADD_REQUEST(isp, iptr);
2205 1.36 mjacob
2206 1.43 mjacob if (isp_getrqentry(isp, &iptr, &optr, (void **)&reqp)) {
2207 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG0,
2208 1.57 mjacob "Request Queue Overflow+");
2209 1.36 mjacob XS_SETERR(xs, HBA_BOTCH);
2210 1.36 mjacob return (CMD_EAGAIN);
2211 1.36 mjacob }
2212 1.1 cgd }
2213 1.1 cgd }
2214 1.1 cgd
2215 1.30 mjacob MEMZERO((void *) reqp, UZSIZE);
2216 1.10 mjacob reqp->req_header.rqs_entry_count = 1;
2217 1.38 mjacob if (IS_FC(isp)) {
2218 1.10 mjacob reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
2219 1.10 mjacob } else {
2220 1.50 mjacob if (XS_CDBLEN(xs) > 12)
2221 1.50 mjacob reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
2222 1.50 mjacob else
2223 1.50 mjacob reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
2224 1.10 mjacob }
2225 1.10 mjacob reqp->req_header.rqs_flags = 0;
2226 1.38 mjacob reqp->req_header.rqs_seqno = 0;
2227 1.38 mjacob if (IS_FC(isp)) {
2228 1.10 mjacob /*
2229 1.10 mjacob * See comment in isp_intr
2230 1.10 mjacob */
2231 1.23 mjacob XS_RESID(xs) = 0;
2232 1.34 mjacob
2233 1.10 mjacob /*
2234 1.42 mjacob * Fibre Channel always requires some kind of tag.
2235 1.42 mjacob * The Qlogic drivers seem be happy not to use a tag,
2236 1.42 mjacob * but this breaks for some devices (IBM drives).
2237 1.10 mjacob */
2238 1.57 mjacob if (XS_TAG_P(xs)) {
2239 1.57 mjacob t2reqp->req_flags = XS_TAG_TYPE(xs);
2240 1.42 mjacob } else {
2241 1.60 mjacob /*
2242 1.60 mjacob * If we don't know what tag to use, use HEAD OF QUEUE
2243 1.60 mjacob * for Request Sense or Ordered (for safety's sake).
2244 1.60 mjacob */
2245 1.42 mjacob if (XS_CDBP(xs)[0] == 0x3) /* REQUEST SENSE */
2246 1.42 mjacob t2reqp->req_flags = REQFLAG_HTAG;
2247 1.42 mjacob else
2248 1.60 mjacob t2reqp->req_flags = REQFLAG_OTAG;
2249 1.10 mjacob }
2250 1.10 mjacob } else {
2251 1.23 mjacob sdparam *sdp = (sdparam *)isp->isp_param;
2252 1.37 mjacob if ((sdp->isp_devparam[target].cur_dflags & DPARM_TQING) &&
2253 1.57 mjacob XS_TAG_P(xs)) {
2254 1.57 mjacob reqp->req_flags = XS_TAG_TYPE(xs);
2255 1.10 mjacob }
2256 1.10 mjacob }
2257 1.37 mjacob reqp->req_target = target | (XS_CHANNEL(xs) << 7);
2258 1.38 mjacob if (IS_SCSI(isp)) {
2259 1.28 mjacob reqp->req_lun_trn = XS_LUN(xs);
2260 1.23 mjacob reqp->req_cdblen = XS_CDBLEN(xs);
2261 1.28 mjacob } else {
2262 1.54 mjacob if (isp->isp_maxluns > 16)
2263 1.54 mjacob t2reqp->req_scclun = XS_LUN(xs);
2264 1.54 mjacob else
2265 1.54 mjacob t2reqp->req_lun_trn = XS_LUN(xs);
2266 1.10 mjacob }
2267 1.31 mjacob MEMCPY(reqp->req_cdb, XS_CDBP(xs), XS_CDBLEN(xs));
2268 1.1 cgd
2269 1.23 mjacob reqp->req_time = XS_TIME(xs) / 1000;
2270 1.23 mjacob if (reqp->req_time == 0 && XS_TIME(xs))
2271 1.10 mjacob reqp->req_time = 1;
2272 1.33 mjacob
2273 1.33 mjacob /*
2274 1.33 mjacob * Always give a bit more leeway to commands after a bus reset.
2275 1.36 mjacob * XXX: DOES NOT DISTINGUISH WHICH PORT MAY HAVE BEEN SYNCED
2276 1.33 mjacob */
2277 1.38 mjacob if (isp->isp_sendmarker && reqp->req_time < 5) {
2278 1.33 mjacob reqp->req_time = 5;
2279 1.38 mjacob }
2280 1.38 mjacob if (isp_save_xs(isp, xs, &reqp->req_handle)) {
2281 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG1, "out of xflist pointers");
2282 1.38 mjacob XS_SETERR(xs, HBA_BOTCH);
2283 1.38 mjacob return (CMD_EAGAIN);
2284 1.38 mjacob }
2285 1.38 mjacob /*
2286 1.38 mjacob * Set up DMA and/or do any bus swizzling of the request entry
2287 1.38 mjacob * so that the Qlogic F/W understands what is being asked of it.
2288 1.38 mjacob */
2289 1.27 mjacob i = ISP_DMASETUP(isp, xs, reqp, &iptr, optr);
2290 1.27 mjacob if (i != CMD_QUEUED) {
2291 1.38 mjacob isp_destroy_handle(isp, reqp->req_handle);
2292 1.27 mjacob /*
2293 1.27 mjacob * dmasetup sets actual error in packet, and
2294 1.27 mjacob * return what we were given to return.
2295 1.27 mjacob */
2296 1.27 mjacob return (i);
2297 1.1 cgd }
2298 1.23 mjacob XS_SETERR(xs, HBA_NOERROR);
2299 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG2,
2300 1.57 mjacob "START cmd for %d.%d.%d cmd 0x%x datalen %d",
2301 1.57 mjacob XS_CHANNEL(xs), target, XS_LUN(xs), XS_CDBP(xs)[0], XS_XFRLEN(xs));
2302 1.43 mjacob ISP_ADD_REQUEST(isp, iptr);
2303 1.23 mjacob isp->isp_nactive++;
2304 1.33 mjacob if (isp->isp_sendmarker)
2305 1.33 mjacob isp->isp_sendmarker = 0;
2306 1.23 mjacob return (CMD_QUEUED);
2307 1.10 mjacob #undef reqp
2308 1.10 mjacob #undef t2reqp
2309 1.1 cgd }
2310 1.1 cgd
2311 1.1 cgd /*
2312 1.23 mjacob * isp control
2313 1.23 mjacob * Locks (ints blocked) assumed held.
2314 1.1 cgd */
2315 1.1 cgd
2316 1.1 cgd int
2317 1.23 mjacob isp_control(isp, ctl, arg)
2318 1.1 cgd struct ispsoftc *isp;
2319 1.23 mjacob ispctl_t ctl;
2320 1.23 mjacob void *arg;
2321 1.1 cgd {
2322 1.57 mjacob XS_T *xs;
2323 1.23 mjacob mbreg_t mbs;
2324 1.38 mjacob int bus, tgt;
2325 1.38 mjacob u_int32_t handle;
2326 1.3 cgd
2327 1.23 mjacob switch (ctl) {
2328 1.23 mjacob default:
2329 1.57 mjacob isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
2330 1.23 mjacob break;
2331 1.3 cgd
2332 1.23 mjacob case ISPCTL_RESET_BUS:
2333 1.33 mjacob /*
2334 1.33 mjacob * Issue a bus reset.
2335 1.33 mjacob */
2336 1.23 mjacob mbs.param[0] = MBOX_BUS_RESET;
2337 1.50 mjacob mbs.param[2] = 0;
2338 1.38 mjacob if (IS_SCSI(isp)) {
2339 1.32 mjacob mbs.param[1] =
2340 1.32 mjacob ((sdparam *) isp->isp_param)->isp_bus_reset_delay;
2341 1.33 mjacob if (mbs.param[1] < 2)
2342 1.33 mjacob mbs.param[1] = 2;
2343 1.38 mjacob bus = *((int *) arg);
2344 1.50 mjacob if (IS_DUALBUS(isp))
2345 1.50 mjacob mbs.param[2] = bus;
2346 1.32 mjacob } else {
2347 1.38 mjacob mbs.param[1] = 10;
2348 1.38 mjacob bus = 0;
2349 1.32 mjacob }
2350 1.52 he isp->isp_sendmarker |= (1 << bus);
2351 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
2352 1.23 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2353 1.23 mjacob break;
2354 1.23 mjacob }
2355 1.57 mjacob isp_prt(isp, ISP_LOGINFO,
2356 1.57 mjacob "driver initiated bus reset of bus %d", bus);
2357 1.23 mjacob return (0);
2358 1.23 mjacob
2359 1.34 mjacob case ISPCTL_RESET_DEV:
2360 1.36 mjacob tgt = (*((int *) arg)) & 0xffff;
2361 1.36 mjacob bus = (*((int *) arg)) >> 16;
2362 1.23 mjacob mbs.param[0] = MBOX_ABORT_TARGET;
2363 1.36 mjacob mbs.param[1] = (tgt << 8) | (bus << 15);
2364 1.32 mjacob mbs.param[2] = 3; /* 'delay', in seconds */
2365 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
2366 1.23 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2367 1.23 mjacob break;
2368 1.23 mjacob }
2369 1.57 mjacob isp_prt(isp, ISP_LOGINFO,
2370 1.57 mjacob "Target %d on Bus %d Reset Succeeded", tgt, bus);
2371 1.52 he isp->isp_sendmarker |= (1 << bus);
2372 1.23 mjacob return (0);
2373 1.23 mjacob
2374 1.34 mjacob case ISPCTL_ABORT_CMD:
2375 1.57 mjacob xs = (XS_T *) arg;
2376 1.54 mjacob tgt = XS_TGT(xs);
2377 1.38 mjacob handle = isp_find_handle(isp, xs);
2378 1.38 mjacob if (handle == 0) {
2379 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
2380 1.57 mjacob "cannot find handle for command to abort");
2381 1.23 mjacob break;
2382 1.23 mjacob }
2383 1.38 mjacob bus = XS_CHANNEL(xs);
2384 1.23 mjacob mbs.param[0] = MBOX_ABORT;
2385 1.38 mjacob if (IS_FC(isp)) {
2386 1.54 mjacob if (isp->isp_maxluns > 16) {
2387 1.54 mjacob mbs.param[1] = tgt << 8;
2388 1.54 mjacob mbs.param[4] = 0;
2389 1.54 mjacob mbs.param[5] = 0;
2390 1.54 mjacob mbs.param[6] = XS_LUN(xs);
2391 1.54 mjacob } else {
2392 1.54 mjacob mbs.param[1] = tgt << 8 | XS_LUN(xs);
2393 1.54 mjacob }
2394 1.28 mjacob } else {
2395 1.38 mjacob mbs.param[1] =
2396 1.38 mjacob (bus << 15) | (XS_TGT(xs) << 8) | XS_LUN(xs);
2397 1.28 mjacob }
2398 1.50 mjacob mbs.param[3] = handle >> 16;
2399 1.50 mjacob mbs.param[2] = handle & 0xffff;
2400 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_ERROR);
2401 1.57 mjacob if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
2402 1.57 mjacob return (0);
2403 1.23 mjacob }
2404 1.61 mjacob /*
2405 1.61 mjacob * XXX: Look for command in the REQUEST QUEUE. That is,
2406 1.61 mjacob * XXX: It hasen't been picked up by firmware yet.
2407 1.61 mjacob */
2408 1.57 mjacob break;
2409 1.26 mjacob
2410 1.26 mjacob case ISPCTL_UPDATE_PARAMS:
2411 1.26 mjacob isp_update(isp);
2412 1.34 mjacob return (0);
2413 1.33 mjacob
2414 1.33 mjacob case ISPCTL_FCLINK_TEST:
2415 1.54 mjacob if (IS_FC(isp)) {
2416 1.57 mjacob int usdelay = (arg)? *((int *) arg) : 250000;
2417 1.57 mjacob return (isp_fclink_test(isp, usdelay));
2418 1.54 mjacob }
2419 1.54 mjacob break;
2420 1.46 mjacob
2421 1.46 mjacob case ISPCTL_PDB_SYNC:
2422 1.54 mjacob if (IS_FC(isp)) {
2423 1.54 mjacob return (isp_pdb_sync(isp, -1));
2424 1.54 mjacob }
2425 1.54 mjacob break;
2426 1.43 mjacob #ifdef ISP_TARGET_MODE
2427 1.46 mjacob case ISPCTL_TOGGLE_TMODE:
2428 1.58 mjacob {
2429 1.58 mjacob int ena = *(int *)arg;
2430 1.46 mjacob if (IS_SCSI(isp)) {
2431 1.46 mjacob mbs.param[0] = MBOX_ENABLE_TARGET_MODE;
2432 1.46 mjacob mbs.param[1] = (ena)? ENABLE_TARGET_FLAG : 0;
2433 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
2434 1.46 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2435 1.46 mjacob break;
2436 1.46 mjacob }
2437 1.58 mjacob } else {
2438 1.58 mjacob fcparam *fcp = isp->isp_param;
2439 1.58 mjacob /*
2440 1.58 mjacob * We assume somebody has quiesced this bus.
2441 1.58 mjacob */
2442 1.58 mjacob if (ena) {
2443 1.58 mjacob if (fcp->isp_fwoptions & ICBOPT_TGT_ENABLE) {
2444 1.58 mjacob return (0);
2445 1.58 mjacob }
2446 1.58 mjacob fcp->isp_fwoptions |= ICBOPT_TGT_ENABLE;
2447 1.58 mjacob } else {
2448 1.58 mjacob if (!(fcp->isp_fwoptions & ICBOPT_TGT_ENABLE)) {
2449 1.58 mjacob return (0);
2450 1.58 mjacob }
2451 1.58 mjacob fcp->isp_fwoptions &= ~ICBOPT_TGT_ENABLE;
2452 1.58 mjacob }
2453 1.60 mjacob isp->isp_state = ISP_NILSTATE;
2454 1.60 mjacob isp_reset(isp);
2455 1.60 mjacob if (isp->isp_state != ISP_RESETSTATE) {
2456 1.60 mjacob break;
2457 1.60 mjacob }
2458 1.60 mjacob isp_init(isp);
2459 1.58 mjacob if (isp->isp_state != ISP_INITSTATE) {
2460 1.58 mjacob break;
2461 1.58 mjacob }
2462 1.60 mjacob isp->isp_state = ISP_RUNSTATE;
2463 1.46 mjacob }
2464 1.46 mjacob return (0);
2465 1.58 mjacob }
2466 1.43 mjacob #endif
2467 1.1 cgd }
2468 1.23 mjacob return (-1);
2469 1.1 cgd }
2470 1.1 cgd
2471 1.23 mjacob /*
2472 1.23 mjacob * Interrupt Service Routine(s).
2473 1.23 mjacob *
2474 1.23 mjacob * External (OS) framework has done the appropriate locking,
2475 1.23 mjacob * and the locking will be held throughout this function.
2476 1.23 mjacob */
2477 1.23 mjacob
2478 1.57 mjacob /*
2479 1.57 mjacob * Limit our stack depth by sticking with the max likely number
2480 1.57 mjacob * of completions on a request queue at any one time.
2481 1.57 mjacob */
2482 1.57 mjacob #define MAX_REQUESTQ_COMPLETIONS 32
2483 1.57 mjacob
2484 1.1 cgd int
2485 1.1 cgd isp_intr(arg)
2486 1.1 cgd void *arg;
2487 1.1 cgd {
2488 1.1 cgd struct ispsoftc *isp = arg;
2489 1.57 mjacob XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
2490 1.54 mjacob u_int16_t iptr, optr, isr, sema, junk;
2491 1.32 mjacob int i, nlooked = 0, ndone = 0;
2492 1.1 cgd
2493 1.54 mjacob if (IS_2100(isp)) {
2494 1.54 mjacob i = 0;
2495 1.54 mjacob do {
2496 1.54 mjacob isr = ISP_READ(isp, BIU_ISR);
2497 1.54 mjacob junk = ISP_READ(isp, BIU_ISR);
2498 1.54 mjacob } while (isr != junk && ++i < 1000);
2499 1.54 mjacob if (isr != junk) {
2500 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
2501 1.57 mjacob "isr unsteady (%x, %x)", isr, junk);
2502 1.54 mjacob }
2503 1.54 mjacob i = 0;
2504 1.54 mjacob do {
2505 1.54 mjacob sema = ISP_READ(isp, BIU_SEMA);
2506 1.54 mjacob junk = ISP_READ(isp, BIU_SEMA);
2507 1.54 mjacob } while (sema != junk && ++i < 1000);
2508 1.54 mjacob if (sema != junk) {
2509 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
2510 1.57 mjacob "sema unsteady (%x, %x)", sema, junk);
2511 1.54 mjacob }
2512 1.54 mjacob } else {
2513 1.54 mjacob isr = ISP_READ(isp, BIU_ISR);
2514 1.54 mjacob sema = ISP_READ(isp, BIU_SEMA);
2515 1.54 mjacob }
2516 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG3, "isp_intr isr %x sem %x", isr, sema);
2517 1.54 mjacob isr &= INT_PENDING_MASK(isp);
2518 1.54 mjacob sema &= BIU_SEMA_LOCK;
2519 1.54 mjacob if (isr == 0 && sema == 0) {
2520 1.39 mjacob return (0);
2521 1.1 cgd }
2522 1.1 cgd
2523 1.36 mjacob if (sema) {
2524 1.54 mjacob u_int16_t mbox;
2525 1.54 mjacob
2526 1.54 mjacob if (IS_2100(isp)) {
2527 1.54 mjacob i = 0;
2528 1.54 mjacob do {
2529 1.54 mjacob mbox = ISP_READ(isp, OUTMAILBOX0);
2530 1.54 mjacob junk = ISP_READ(isp, OUTMAILBOX0);;
2531 1.54 mjacob } while (junk != mbox && ++i < 1000);
2532 1.54 mjacob if (mbox != junk) {
2533 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
2534 1.57 mjacob "mailbox0 unsteady (%x, %x)", mbox, junk);
2535 1.54 mjacob ISP_WRITE(isp, BIU_SEMA, 0);
2536 1.54 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
2537 1.54 mjacob return (1);
2538 1.54 mjacob }
2539 1.54 mjacob } else {
2540 1.54 mjacob mbox = ISP_READ(isp, OUTMAILBOX0);
2541 1.54 mjacob }
2542 1.33 mjacob if (mbox & 0x4000) {
2543 1.54 mjacob int obits, i = 0;
2544 1.54 mjacob if ((obits = isp->isp_mboxbsy) != 0) {
2545 1.54 mjacob isp->isp_mboxtmp[i++] = mbox;
2546 1.54 mjacob for (i = 1; i < 8; i++) {
2547 1.54 mjacob if ((obits & (1 << i)) == 0) {
2548 1.54 mjacob continue;
2549 1.54 mjacob }
2550 1.54 mjacob isp->isp_mboxtmp[i] =
2551 1.54 mjacob ISP_READ(isp, MBOX_OFF(i));
2552 1.54 mjacob }
2553 1.54 mjacob MBOX_NOTIFY_COMPLETE(isp);
2554 1.54 mjacob } else {
2555 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
2556 1.57 mjacob "Mbox Command Async (0x%x) with no waiters",
2557 1.57 mjacob mbox);
2558 1.54 mjacob }
2559 1.33 mjacob } else {
2560 1.33 mjacob u_int32_t fhandle = isp_parse_async(isp, (int) mbox);
2561 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
2562 1.35 mjacob if (fhandle > 0) {
2563 1.38 mjacob isp_fastpost_complete(isp, fhandle);
2564 1.33 mjacob }
2565 1.31 mjacob }
2566 1.54 mjacob if (IS_FC(isp) || isp->isp_state != ISP_RUNSTATE) {
2567 1.54 mjacob ISP_WRITE(isp, BIU_SEMA, 0);
2568 1.54 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
2569 1.54 mjacob return (1);
2570 1.54 mjacob }
2571 1.54 mjacob }
2572 1.54 mjacob
2573 1.54 mjacob /*
2574 1.54 mjacob * We can't be getting this now.
2575 1.54 mjacob */
2576 1.54 mjacob if (isp->isp_state != ISP_RUNSTATE) {
2577 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
2578 1.57 mjacob "interrupt (isr=%x, sema=%x) when not ready", isr, sema);
2579 1.54 mjacob ISP_WRITE(isp, INMAILBOX5, ISP_READ(isp, OUTMAILBOX5));
2580 1.54 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
2581 1.35 mjacob ISP_WRITE(isp, BIU_SEMA, 0);
2582 1.35 mjacob return (1);
2583 1.1 cgd }
2584 1.25 mjacob
2585 1.35 mjacob /*
2586 1.35 mjacob * You *must* read OUTMAILBOX5 prior to clearing the RISC interrupt.
2587 1.35 mjacob */
2588 1.24 mjacob optr = isp->isp_residx;
2589 1.54 mjacob
2590 1.54 mjacob if (IS_2100(isp)) {
2591 1.54 mjacob i = 0;
2592 1.54 mjacob do {
2593 1.54 mjacob iptr = ISP_READ(isp, OUTMAILBOX5);
2594 1.54 mjacob junk = ISP_READ(isp, OUTMAILBOX5);
2595 1.54 mjacob } while (junk != iptr && ++i < 1000);
2596 1.54 mjacob
2597 1.54 mjacob if (iptr != junk) {
2598 1.54 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
2599 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
2600 1.57 mjacob "mailbox5 unsteady (%x, %x)", iptr, junk);
2601 1.54 mjacob return (1);
2602 1.54 mjacob }
2603 1.54 mjacob } else {
2604 1.54 mjacob iptr = ISP_READ(isp, OUTMAILBOX5);
2605 1.54 mjacob }
2606 1.54 mjacob
2607 1.54 mjacob if (sema) {
2608 1.54 mjacob ISP_WRITE(isp, BIU_SEMA, 0);
2609 1.54 mjacob }
2610 1.35 mjacob ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
2611 1.54 mjacob
2612 1.54 mjacob if (optr == iptr && sema == 0) {
2613 1.54 mjacob /*
2614 1.54 mjacob * There are a lot of these- reasons unknown- mostly on
2615 1.54 mjacob * faster Alpha machines.
2616 1.54 mjacob *
2617 1.54 mjacob * I tried delaying after writing HCCR_CMD_CLEAR_RISC_INT to
2618 1.54 mjacob * make sure the old interrupt went away (to avoid 'ringing'
2619 1.54 mjacob * effects), but that didn't stop this from occurring.
2620 1.54 mjacob */
2621 1.54 mjacob junk = ISP_READ(isp, BIU_ISR);
2622 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG2,
2623 1.57 mjacob "bogus intr- isr %x (%x) iptr %x optr %x",
2624 1.57 mjacob isr, junk, iptr, optr);
2625 1.10 mjacob }
2626 1.10 mjacob
2627 1.1 cgd while (optr != iptr) {
2628 1.1 cgd ispstatusreq_t *sp;
2629 1.43 mjacob u_int16_t oop;
2630 1.1 cgd int buddaboom = 0;
2631 1.1 cgd
2632 1.7 thorpej sp = (ispstatusreq_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
2633 1.25 mjacob oop = optr;
2634 1.57 mjacob optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
2635 1.32 mjacob nlooked++;
2636 1.38 mjacob /*
2637 1.38 mjacob * Do any appropriate unswizzling of what the Qlogic f/w has
2638 1.46 mjacob * written into memory so it makes sense to us. This is a
2639 1.57 mjacob * per-platform thing. Also includes any memory barriers.
2640 1.38 mjacob */
2641 1.57 mjacob ISP_UNSWIZZLE_RESPONSE(isp, sp, oop);
2642 1.1 cgd if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) {
2643 1.25 mjacob if (isp_handle_other_response(isp, sp, &optr) == 0) {
2644 1.61 mjacob MEMZERO(sp, sizeof (isphdr_t));
2645 1.25 mjacob continue;
2646 1.25 mjacob }
2647 1.25 mjacob /*
2648 1.25 mjacob * It really has to be a bounced request just copied
2649 1.36 mjacob * from the request queue to the response queue. If
2650 1.36 mjacob * not, something bad has happened.
2651 1.25 mjacob */
2652 1.1 cgd if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) {
2653 1.57 mjacob isp_prt(isp, ISP_LOGERR, notresp,
2654 1.36 mjacob sp->req_header.rqs_entry_type, oop, optr);
2655 1.61 mjacob MEMZERO(sp, sizeof (isphdr_t));
2656 1.1 cgd continue;
2657 1.1 cgd }
2658 1.1 cgd buddaboom = 1;
2659 1.1 cgd }
2660 1.1 cgd
2661 1.1 cgd if (sp->req_header.rqs_flags & 0xf) {
2662 1.36 mjacob #define _RQS_OFLAGS \
2663 1.36 mjacob ~(RQSFLAG_CONTINUATION|RQSFLAG_FULL|RQSFLAG_BADHEADER|RQSFLAG_BADPACKET)
2664 1.1 cgd if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
2665 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
2666 1.57 mjacob "continuation segment");
2667 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
2668 1.1 cgd continue;
2669 1.1 cgd }
2670 1.23 mjacob if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
2671 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG1,
2672 1.57 mjacob "internal queues full");
2673 1.36 mjacob /*
2674 1.36 mjacob * We'll synthesize a QUEUE FULL message below.
2675 1.36 mjacob */
2676 1.23 mjacob }
2677 1.23 mjacob if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
2678 1.57 mjacob isp_prt(isp, ISP_LOGERR, "bad header flag");
2679 1.23 mjacob buddaboom++;
2680 1.23 mjacob }
2681 1.23 mjacob if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
2682 1.57 mjacob isp_prt(isp, ISP_LOGERR, "bad request packet");
2683 1.23 mjacob buddaboom++;
2684 1.23 mjacob }
2685 1.36 mjacob if (sp->req_header.rqs_flags & _RQS_OFLAGS) {
2686 1.57 mjacob isp_prt(isp, ISP_LOGERR,
2687 1.57 mjacob "unknown flags (0x%x) in response",
2688 1.57 mjacob sp->req_header.rqs_flags);
2689 1.36 mjacob buddaboom++;
2690 1.36 mjacob }
2691 1.36 mjacob #undef _RQS_OFLAGS
2692 1.1 cgd }
2693 1.38 mjacob if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) {
2694 1.61 mjacob MEMZERO(sp, sizeof (isphdr_t));
2695 1.57 mjacob isp_prt(isp, ISP_LOGERR,
2696 1.57 mjacob "bad request handle %d", sp->req_handle);
2697 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
2698 1.1 cgd continue;
2699 1.1 cgd }
2700 1.38 mjacob xs = isp_find_xs(isp, sp->req_handle);
2701 1.1 cgd if (xs == NULL) {
2702 1.61 mjacob MEMZERO(sp, sizeof (isphdr_t));
2703 1.57 mjacob isp_prt(isp, ISP_LOGERR,
2704 1.57 mjacob "cannot find handle 0x%x in xflist",
2705 1.57 mjacob sp->req_handle);
2706 1.1 cgd ISP_WRITE(isp, INMAILBOX5, optr);
2707 1.1 cgd continue;
2708 1.1 cgd }
2709 1.38 mjacob isp_destroy_handle(isp, sp->req_handle);
2710 1.1 cgd if (sp->req_status_flags & RQSTF_BUS_RESET) {
2711 1.36 mjacob isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
2712 1.1 cgd }
2713 1.1 cgd if (buddaboom) {
2714 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
2715 1.1 cgd }
2716 1.61 mjacob
2717 1.61 mjacob if (IS_FC(isp) && (sp->req_scsi_status & RQCS_SV)) {
2718 1.31 mjacob /*
2719 1.61 mjacob * Fibre Channel F/W doesn't say we got status
2720 1.61 mjacob * if there's Sense Data instead. I guess they
2721 1.61 mjacob * think it goes w/o saying.
2722 1.31 mjacob */
2723 1.61 mjacob sp->req_state_flags |= RQSF_GOT_STATUS;
2724 1.61 mjacob }
2725 1.61 mjacob if (sp->req_state_flags & RQSF_GOT_STATUS) {
2726 1.61 mjacob *XS_STSP(xs) = sp->req_scsi_status & 0xff;
2727 1.1 cgd }
2728 1.1 cgd
2729 1.61 mjacob switch (sp->req_header.rqs_entry_type) {
2730 1.61 mjacob case RQSTYPE_RESPONSE:
2731 1.57 mjacob XS_SET_STATE_STAT(isp, xs, sp);
2732 1.57 mjacob isp_parse_status(isp, sp, xs);
2733 1.57 mjacob if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
2734 1.57 mjacob (*XS_STSP(xs) == SCSI_BUSY)) {
2735 1.57 mjacob XS_SETERR(xs, HBA_TGTBSY);
2736 1.25 mjacob }
2737 1.61 mjacob if (IS_SCSI(isp)) {
2738 1.61 mjacob XS_RESID(xs) = sp->req_resid;
2739 1.61 mjacob if ((sp->req_state_flags & RQSF_GOT_STATUS) &&
2740 1.61 mjacob (*XS_STSP(xs) == SCSI_CHECK) &&
2741 1.61 mjacob (sp->req_state_flags & RQSF_GOT_SENSE)) {
2742 1.61 mjacob XS_SAVE_SENSE(xs, sp);
2743 1.61 mjacob }
2744 1.61 mjacob /*
2745 1.61 mjacob * A new synchronous rate was negotiated for
2746 1.61 mjacob * this target. Mark state such that we'll go
2747 1.61 mjacob * look up that which has changed later.
2748 1.61 mjacob */
2749 1.61 mjacob if (sp->req_status_flags & RQSTF_NEGOTIATION) {
2750 1.61 mjacob int t = XS_TGT(xs);
2751 1.61 mjacob sdparam *sdp = isp->isp_param;
2752 1.61 mjacob sdp += XS_CHANNEL(xs);
2753 1.61 mjacob sdp->isp_devparam[t].dev_refresh = 1;
2754 1.61 mjacob isp->isp_update |=
2755 1.61 mjacob (1 << XS_CHANNEL(xs));
2756 1.61 mjacob }
2757 1.61 mjacob } else {
2758 1.61 mjacob if (sp->req_status_flags & RQSF_XFER_COMPLETE) {
2759 1.61 mjacob XS_RESID(xs) = 0;
2760 1.61 mjacob } else if (sp->req_scsi_status & RQCS_RESID) {
2761 1.61 mjacob XS_RESID(xs) = sp->req_resid;
2762 1.61 mjacob } else {
2763 1.61 mjacob XS_RESID(xs) = 0;
2764 1.61 mjacob }
2765 1.61 mjacob if ((sp->req_state_flags & RQSF_GOT_STATUS) &&
2766 1.61 mjacob (*XS_STSP(xs) == SCSI_CHECK) &&
2767 1.61 mjacob (sp->req_scsi_status & RQCS_SV)) {
2768 1.61 mjacob XS_SAVE_SENSE(xs, sp);
2769 1.61 mjacob }
2770 1.61 mjacob }
2771 1.61 mjacob isp_prt(isp, ISP_LOGDEBUG2, "asked for %d got resid %d",
2772 1.61 mjacob XS_XFRLEN(xs), sp->req_resid);
2773 1.61 mjacob break;
2774 1.61 mjacob case RQSTYPE_REQUEST:
2775 1.36 mjacob if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
2776 1.36 mjacob /*
2777 1.36 mjacob * Force Queue Full status.
2778 1.36 mjacob */
2779 1.57 mjacob *XS_STSP(xs) = SCSI_QFULL;
2780 1.36 mjacob XS_SETERR(xs, HBA_NOERROR);
2781 1.36 mjacob } else if (XS_NOERR(xs)) {
2782 1.36 mjacob XS_SETERR(xs, HBA_BOTCH);
2783 1.36 mjacob }
2784 1.61 mjacob XS_RESID(xs) = XS_XFRLEN(xs);
2785 1.61 mjacob break;
2786 1.61 mjacob default:
2787 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
2788 1.57 mjacob "unhandled respose queue type 0x%x",
2789 1.57 mjacob sp->req_header.rqs_entry_type);
2790 1.30 mjacob if (XS_NOERR(xs)) {
2791 1.23 mjacob XS_SETERR(xs, HBA_BOTCH);
2792 1.30 mjacob }
2793 1.61 mjacob break;
2794 1.1 cgd }
2795 1.61 mjacob
2796 1.61 mjacob /*
2797 1.61 mjacob * Free any dma resources. As a side effect, this may
2798 1.61 mjacob * also do any cache flushing necessary for data coherence. */
2799 1.23 mjacob if (XS_XFRLEN(xs)) {
2800 1.38 mjacob ISP_DMAFREE(isp, xs, sp->req_handle);
2801 1.1 cgd }
2802 1.61 mjacob
2803 1.57 mjacob if (((isp->isp_dblev & (ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
2804 1.57 mjacob ((isp->isp_dblev & ISP_LOGDEBUG1) && !XS_NOERR(xs))) {
2805 1.57 mjacob char skey;
2806 1.10 mjacob if (sp->req_state_flags & RQSF_GOT_SENSE) {
2807 1.57 mjacob skey = XS_SNSKEY(xs) & 0xf;
2808 1.57 mjacob if (skey < 10)
2809 1.57 mjacob skey += '0';
2810 1.57 mjacob else
2811 1.57 mjacob skey += 'a';
2812 1.57 mjacob } else if (*XS_STSP(xs) == SCSI_CHECK) {
2813 1.57 mjacob skey = '?';
2814 1.57 mjacob } else {
2815 1.57 mjacob skey = '.';
2816 1.1 cgd }
2817 1.57 mjacob isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs),
2818 1.57 mjacob XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs), XS_RESID(xs),
2819 1.57 mjacob *XS_STSP(xs), skey, XS_ERR(xs));
2820 1.1 cgd }
2821 1.23 mjacob
2822 1.28 mjacob if (isp->isp_nactive > 0)
2823 1.28 mjacob isp->isp_nactive--;
2824 1.25 mjacob complist[ndone++] = xs; /* defer completion call until later */
2825 1.61 mjacob MEMZERO(sp, sizeof (isphdr_t));
2826 1.57 mjacob if (ndone == MAX_REQUESTQ_COMPLETIONS) {
2827 1.57 mjacob break;
2828 1.57 mjacob }
2829 1.1 cgd }
2830 1.32 mjacob
2831 1.27 mjacob /*
2832 1.32 mjacob * If we looked at any commands, then it's valid to find out
2833 1.32 mjacob * what the outpointer is. It also is a trigger to update the
2834 1.32 mjacob * ISP's notion of what we've seen so far.
2835 1.27 mjacob */
2836 1.33 mjacob if (nlooked) {
2837 1.32 mjacob ISP_WRITE(isp, INMAILBOX5, optr);
2838 1.34 mjacob isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4);
2839 1.27 mjacob }
2840 1.54 mjacob
2841 1.1 cgd isp->isp_residx = optr;
2842 1.25 mjacob for (i = 0; i < ndone; i++) {
2843 1.25 mjacob xs = complist[i];
2844 1.25 mjacob if (xs) {
2845 1.57 mjacob isp_done(xs);
2846 1.25 mjacob }
2847 1.25 mjacob }
2848 1.1 cgd return (1);
2849 1.1 cgd }
2850 1.1 cgd
2851 1.1 cgd /*
2852 1.1 cgd * Support routines.
2853 1.1 cgd */
2854 1.1 cgd
2855 1.25 mjacob static int
2856 1.25 mjacob isp_parse_async(isp, mbox)
2857 1.25 mjacob struct ispsoftc *isp;
2858 1.28 mjacob int mbox;
2859 1.25 mjacob {
2860 1.43 mjacob int bus;
2861 1.31 mjacob u_int32_t fast_post_handle = 0;
2862 1.31 mjacob
2863 1.44 mjacob if (IS_DUALBUS(isp)) {
2864 1.43 mjacob bus = ISP_READ(isp, OUTMAILBOX6);
2865 1.43 mjacob } else {
2866 1.43 mjacob bus = 0;
2867 1.43 mjacob }
2868 1.43 mjacob
2869 1.25 mjacob switch (mbox) {
2870 1.25 mjacob case ASYNC_BUS_RESET:
2871 1.52 he isp->isp_sendmarker |= (1 << bus);
2872 1.29 mjacob #ifdef ISP_TARGET_MODE
2873 1.46 mjacob isp_target_async(isp, bus, mbox);
2874 1.29 mjacob #endif
2875 1.43 mjacob isp_async(isp, ISPASYNC_BUS_RESET, &bus);
2876 1.25 mjacob break;
2877 1.25 mjacob case ASYNC_SYSTEM_ERROR:
2878 1.25 mjacob mbox = ISP_READ(isp, OUTMAILBOX1);
2879 1.57 mjacob isp_prt(isp, ISP_LOGERR,
2880 1.57 mjacob "Internal FW Error @ RISC Addr 0x%x", mbox);
2881 1.57 mjacob isp_reinit(isp);
2882 1.25 mjacob /* no point continuing after this */
2883 1.31 mjacob return (-1);
2884 1.25 mjacob
2885 1.25 mjacob case ASYNC_RQS_XFER_ERR:
2886 1.57 mjacob isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
2887 1.25 mjacob break;
2888 1.25 mjacob
2889 1.25 mjacob case ASYNC_RSP_XFER_ERR:
2890 1.57 mjacob isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
2891 1.25 mjacob break;
2892 1.25 mjacob
2893 1.25 mjacob case ASYNC_QWAKEUP:
2894 1.43 mjacob /*
2895 1.43 mjacob * We've just been notified that the Queue has woken up.
2896 1.43 mjacob * We don't need to be chatty about this- just unlatch things
2897 1.43 mjacob * and move on.
2898 1.43 mjacob */
2899 1.25 mjacob mbox = ISP_READ(isp, OUTMAILBOX4);
2900 1.25 mjacob break;
2901 1.25 mjacob
2902 1.25 mjacob case ASYNC_TIMEOUT_RESET:
2903 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
2904 1.57 mjacob "timeout initiated SCSI bus reset of bus %d\n", bus);
2905 1.52 he isp->isp_sendmarker |= (1 << bus);
2906 1.29 mjacob #ifdef ISP_TARGET_MODE
2907 1.46 mjacob isp_target_async(isp, bus, mbox);
2908 1.29 mjacob #endif
2909 1.25 mjacob break;
2910 1.25 mjacob
2911 1.28 mjacob case ASYNC_DEVICE_RESET:
2912 1.57 mjacob isp_prt(isp, ISP_LOGINFO, "device reset on bus %d", bus);
2913 1.52 he isp->isp_sendmarker |= (1 << bus);
2914 1.29 mjacob #ifdef ISP_TARGET_MODE
2915 1.46 mjacob isp_target_async(isp, bus, mbox);
2916 1.29 mjacob #endif
2917 1.25 mjacob break;
2918 1.25 mjacob
2919 1.25 mjacob case ASYNC_EXTMSG_UNDERRUN:
2920 1.57 mjacob isp_prt(isp, ISP_LOGWARN, "extended message underrun");
2921 1.25 mjacob break;
2922 1.25 mjacob
2923 1.25 mjacob case ASYNC_SCAM_INT:
2924 1.57 mjacob isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
2925 1.25 mjacob break;
2926 1.25 mjacob
2927 1.25 mjacob case ASYNC_HUNG_SCSI:
2928 1.57 mjacob isp_prt(isp, ISP_LOGERR,
2929 1.57 mjacob "stalled SCSI Bus after DATA Overrun");
2930 1.25 mjacob /* XXX: Need to issue SCSI reset at this point */
2931 1.25 mjacob break;
2932 1.25 mjacob
2933 1.25 mjacob case ASYNC_KILLED_BUS:
2934 1.57 mjacob isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
2935 1.25 mjacob break;
2936 1.25 mjacob
2937 1.25 mjacob case ASYNC_BUS_TRANSIT:
2938 1.34 mjacob mbox = ISP_READ(isp, OUTMAILBOX2);
2939 1.34 mjacob switch (mbox & 0x1c00) {
2940 1.34 mjacob case SXP_PINS_LVD_MODE:
2941 1.57 mjacob isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
2942 1.58 mjacob SDPARAM(isp)->isp_diffmode = 0;
2943 1.58 mjacob SDPARAM(isp)->isp_ultramode = 0;
2944 1.58 mjacob SDPARAM(isp)->isp_lvdmode = 1;
2945 1.34 mjacob break;
2946 1.34 mjacob case SXP_PINS_HVD_MODE:
2947 1.57 mjacob isp_prt(isp, ISP_LOGINFO,
2948 1.57 mjacob "Transition to Differential mode");
2949 1.58 mjacob SDPARAM(isp)->isp_diffmode = 1;
2950 1.58 mjacob SDPARAM(isp)->isp_ultramode = 0;
2951 1.58 mjacob SDPARAM(isp)->isp_lvdmode = 0;
2952 1.34 mjacob break;
2953 1.34 mjacob case SXP_PINS_SE_MODE:
2954 1.57 mjacob isp_prt(isp, ISP_LOGINFO,
2955 1.57 mjacob "Transition to Single Ended mode");
2956 1.58 mjacob SDPARAM(isp)->isp_diffmode = 0;
2957 1.58 mjacob SDPARAM(isp)->isp_ultramode = 1;
2958 1.58 mjacob SDPARAM(isp)->isp_lvdmode = 0;
2959 1.34 mjacob break;
2960 1.34 mjacob default:
2961 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
2962 1.57 mjacob "Transition to Unknown Mode 0x%x", mbox);
2963 1.34 mjacob break;
2964 1.34 mjacob }
2965 1.34 mjacob /*
2966 1.34 mjacob * XXX: Set up to renegotiate again!
2967 1.34 mjacob */
2968 1.36 mjacob /* Can only be for a 1080... */
2969 1.52 he isp->isp_sendmarker |= (1 << bus);
2970 1.25 mjacob break;
2971 1.25 mjacob
2972 1.25 mjacob case ASYNC_CMD_CMPLT:
2973 1.31 mjacob fast_post_handle = (ISP_READ(isp, OUTMAILBOX2) << 16) |
2974 1.31 mjacob ISP_READ(isp, OUTMAILBOX1);
2975 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG3, "fast post completion of %u",
2976 1.57 mjacob fast_post_handle);
2977 1.25 mjacob break;
2978 1.25 mjacob
2979 1.25 mjacob case ASYNC_CTIO_DONE:
2980 1.58 mjacob #ifdef ISP_TARGET_MODE
2981 1.58 mjacob /*
2982 1.58 mjacob * Bus gets overloaded with the handle. Dual bus
2983 1.58 mjacob * cards don't put bus# into the handle.
2984 1.58 mjacob */
2985 1.58 mjacob bus = (ISP_READ(isp, OUTMAILBOX2) << 16) |
2986 1.58 mjacob ISP_READ(isp, OUTMAILBOX1);
2987 1.58 mjacob isp_target_async(isp, bus, mbox);
2988 1.58 mjacob #else
2989 1.58 mjacob isp_prt(isp, ISP_LOGINFO, "Fast Posting CTIO done");
2990 1.58 mjacob #endif
2991 1.25 mjacob break;
2992 1.25 mjacob
2993 1.25 mjacob case ASYNC_LIP_OCCURRED:
2994 1.60 mjacob FCPARAM(isp)->isp_lipseq =
2995 1.39 mjacob ISP_READ(isp, OUTMAILBOX1);
2996 1.60 mjacob FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
2997 1.60 mjacob FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
2998 1.33 mjacob isp->isp_sendmarker = 1;
2999 1.35 mjacob isp_mark_getpdb_all(isp);
3000 1.57 mjacob isp_prt(isp, ISP_LOGINFO, "LIP occurred");
3001 1.46 mjacob #ifdef ISP_TARGET_MODE
3002 1.46 mjacob isp_target_async(isp, bus, mbox);
3003 1.46 mjacob #endif
3004 1.25 mjacob break;
3005 1.25 mjacob
3006 1.25 mjacob case ASYNC_LOOP_UP:
3007 1.37 mjacob isp->isp_sendmarker = 1;
3008 1.60 mjacob FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
3009 1.60 mjacob FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
3010 1.35 mjacob isp_mark_getpdb_all(isp);
3011 1.32 mjacob isp_async(isp, ISPASYNC_LOOP_UP, NULL);
3012 1.46 mjacob #ifdef ISP_TARGET_MODE
3013 1.46 mjacob isp_target_async(isp, bus, mbox);
3014 1.46 mjacob #endif
3015 1.25 mjacob break;
3016 1.25 mjacob
3017 1.25 mjacob case ASYNC_LOOP_DOWN:
3018 1.37 mjacob isp->isp_sendmarker = 1;
3019 1.60 mjacob FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
3020 1.60 mjacob FCPARAM(isp)->isp_loopstate = LOOP_NIL;
3021 1.35 mjacob isp_mark_getpdb_all(isp);
3022 1.32 mjacob isp_async(isp, ISPASYNC_LOOP_DOWN, NULL);
3023 1.46 mjacob #ifdef ISP_TARGET_MODE
3024 1.46 mjacob isp_target_async(isp, bus, mbox);
3025 1.46 mjacob #endif
3026 1.25 mjacob break;
3027 1.25 mjacob
3028 1.25 mjacob case ASYNC_LOOP_RESET:
3029 1.52 he isp->isp_sendmarker = 1;
3030 1.60 mjacob FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
3031 1.60 mjacob FCPARAM(isp)->isp_loopstate = LOOP_NIL;
3032 1.35 mjacob isp_mark_getpdb_all(isp);
3033 1.57 mjacob isp_prt(isp, ISP_LOGINFO, "Loop RESET");
3034 1.29 mjacob #ifdef ISP_TARGET_MODE
3035 1.46 mjacob isp_target_async(isp, bus, mbox);
3036 1.29 mjacob #endif
3037 1.25 mjacob break;
3038 1.25 mjacob
3039 1.25 mjacob case ASYNC_PDB_CHANGED:
3040 1.33 mjacob isp->isp_sendmarker = 1;
3041 1.60 mjacob FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
3042 1.33 mjacob isp_mark_getpdb_all(isp);
3043 1.57 mjacob isp_prt(isp, ISP_LOGINFO, "Port Database Changed");
3044 1.25 mjacob break;
3045 1.25 mjacob
3046 1.25 mjacob case ASYNC_CHANGE_NOTIFY:
3047 1.38 mjacob isp_mark_getpdb_all(isp);
3048 1.38 mjacob /*
3049 1.38 mjacob * Not correct, but it will force us to rescan the loop.
3050 1.38 mjacob */
3051 1.60 mjacob FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
3052 1.38 mjacob isp_async(isp, ISPASYNC_CHANGE_NOTIFY, NULL);
3053 1.25 mjacob break;
3054 1.25 mjacob
3055 1.49 mjacob case ASYNC_PTPMODE:
3056 1.60 mjacob if (FCPARAM(isp)->isp_onfabric)
3057 1.60 mjacob FCPARAM(isp)->isp_topo = TOPO_N_PORT;
3058 1.52 he else
3059 1.60 mjacob FCPARAM(isp)->isp_topo = TOPO_F_PORT;
3060 1.52 he isp_mark_getpdb_all(isp);
3061 1.52 he isp->isp_sendmarker = 1;
3062 1.60 mjacob FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
3063 1.60 mjacob FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
3064 1.52 he #ifdef ISP_TARGET_MODE
3065 1.52 he isp_target_async(isp, bus, mbox);
3066 1.52 he #endif
3067 1.57 mjacob isp_prt(isp, ISP_LOGINFO, "Point-to-Point mode");
3068 1.49 mjacob break;
3069 1.49 mjacob
3070 1.49 mjacob case ASYNC_CONNMODE:
3071 1.49 mjacob mbox = ISP_READ(isp, OUTMAILBOX1);
3072 1.49 mjacob switch (mbox) {
3073 1.49 mjacob case ISP_CONN_LOOP:
3074 1.57 mjacob isp_prt(isp, ISP_LOGINFO, "Point-to-Point->Loop mode");
3075 1.49 mjacob break;
3076 1.49 mjacob case ISP_CONN_PTP:
3077 1.57 mjacob isp_prt(isp, ISP_LOGINFO, "Loop->Point-to-Point mode");
3078 1.49 mjacob break;
3079 1.49 mjacob case ISP_CONN_BADLIP:
3080 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
3081 1.57 mjacob "Point-to-Point->Loop mode (1)");
3082 1.49 mjacob break;
3083 1.49 mjacob case ISP_CONN_FATAL:
3084 1.57 mjacob isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
3085 1.57 mjacob isp_reinit(isp);
3086 1.49 mjacob /* no point continuing after this */
3087 1.49 mjacob return (-1);
3088 1.49 mjacob
3089 1.49 mjacob case ISP_CONN_LOOPBACK:
3090 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
3091 1.57 mjacob "Looped Back in Point-to-Point mode");
3092 1.49 mjacob }
3093 1.49 mjacob break;
3094 1.49 mjacob
3095 1.25 mjacob default:
3096 1.57 mjacob isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
3097 1.25 mjacob break;
3098 1.25 mjacob }
3099 1.31 mjacob return (fast_post_handle);
3100 1.25 mjacob }
3101 1.25 mjacob
3102 1.43 mjacob /*
3103 1.43 mjacob * Handle other response entries. A pointer to the request queue output
3104 1.43 mjacob * index is here in case we want to eat several entries at once, although
3105 1.43 mjacob * this is not used currently.
3106 1.43 mjacob */
3107 1.43 mjacob
3108 1.25 mjacob static int
3109 1.25 mjacob isp_handle_other_response(isp, sp, optrp)
3110 1.25 mjacob struct ispsoftc *isp;
3111 1.25 mjacob ispstatusreq_t *sp;
3112 1.43 mjacob u_int16_t *optrp;
3113 1.25 mjacob {
3114 1.25 mjacob switch (sp->req_header.rqs_entry_type) {
3115 1.58 mjacob case RQSTYPE_STATUS_CONT:
3116 1.58 mjacob isp_prt(isp, ISP_LOGINFO, "Ignored Continuation Response");
3117 1.58 mjacob return (0);
3118 1.38 mjacob case RQSTYPE_ATIO:
3119 1.46 mjacob case RQSTYPE_CTIO:
3120 1.29 mjacob case RQSTYPE_ENABLE_LUN:
3121 1.29 mjacob case RQSTYPE_MODIFY_LUN:
3122 1.38 mjacob case RQSTYPE_NOTIFY:
3123 1.38 mjacob case RQSTYPE_NOTIFY_ACK:
3124 1.38 mjacob case RQSTYPE_CTIO1:
3125 1.29 mjacob case RQSTYPE_ATIO2:
3126 1.38 mjacob case RQSTYPE_CTIO2:
3127 1.38 mjacob case RQSTYPE_CTIO3:
3128 1.38 mjacob #ifdef ISP_TARGET_MODE
3129 1.46 mjacob return (isp_target_notify(isp, sp, optrp));
3130 1.29 mjacob #else
3131 1.57 mjacob optrp = optrp;
3132 1.38 mjacob /* FALLTHROUGH */
3133 1.29 mjacob #endif
3134 1.38 mjacob case RQSTYPE_REQUEST:
3135 1.25 mjacob default:
3136 1.57 mjacob isp_prt(isp, ISP_LOGWARN, "Unhandled Response Type 0x%x",
3137 1.43 mjacob sp->req_header.rqs_entry_type);
3138 1.29 mjacob return (-1);
3139 1.29 mjacob }
3140 1.29 mjacob }
3141 1.29 mjacob
3142 1.23 mjacob static void
3143 1.10 mjacob isp_parse_status(isp, sp, xs)
3144 1.1 cgd struct ispsoftc *isp;
3145 1.1 cgd ispstatusreq_t *sp;
3146 1.57 mjacob XS_T *xs;
3147 1.1 cgd {
3148 1.57 mjacob switch (sp->req_completion_status & 0xff) {
3149 1.1 cgd case RQCS_COMPLETE:
3150 1.57 mjacob if (XS_NOERR(xs)) {
3151 1.57 mjacob XS_SETERR(xs, HBA_NOERROR);
3152 1.57 mjacob }
3153 1.23 mjacob return;
3154 1.10 mjacob
3155 1.1 cgd case RQCS_INCOMPLETE:
3156 1.1 cgd if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
3157 1.58 mjacob isp_prt(isp, ISP_LOGDEBUG1,
3158 1.57 mjacob "Selection Timeout for %d.%d.%d",
3159 1.57 mjacob XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
3160 1.57 mjacob if (XS_NOERR(xs)) {
3161 1.57 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
3162 1.57 mjacob }
3163 1.23 mjacob return;
3164 1.1 cgd }
3165 1.57 mjacob isp_prt(isp, ISP_LOGERR,
3166 1.57 mjacob "command incomplete for %d.%d.%d, state 0x%x",
3167 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
3168 1.25 mjacob sp->req_state_flags);
3169 1.25 mjacob break;
3170 1.25 mjacob
3171 1.25 mjacob case RQCS_DMA_ERROR:
3172 1.57 mjacob isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
3173 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3174 1.1 cgd break;
3175 1.15 mjacob
3176 1.15 mjacob case RQCS_TRANSPORT_ERROR:
3177 1.57 mjacob {
3178 1.57 mjacob char buf[172];
3179 1.57 mjacob buf[0] = 0;
3180 1.57 mjacob STRNCAT(buf, "states=>", sizeof buf);
3181 1.57 mjacob if (sp->req_state_flags & RQSF_GOT_BUS) {
3182 1.57 mjacob STRNCAT(buf, " GOT_BUS", sizeof buf);
3183 1.57 mjacob }
3184 1.57 mjacob if (sp->req_state_flags & RQSF_GOT_TARGET) {
3185 1.57 mjacob STRNCAT(buf, " GOT_TGT", sizeof buf);
3186 1.57 mjacob }
3187 1.57 mjacob if (sp->req_state_flags & RQSF_SENT_CDB) {
3188 1.57 mjacob STRNCAT(buf, " SENT_CDB", sizeof buf);
3189 1.57 mjacob }
3190 1.57 mjacob if (sp->req_state_flags & RQSF_XFRD_DATA) {
3191 1.57 mjacob STRNCAT(buf, " XFRD_DATA", sizeof buf);
3192 1.57 mjacob }
3193 1.57 mjacob if (sp->req_state_flags & RQSF_GOT_STATUS) {
3194 1.57 mjacob STRNCAT(buf, " GOT_STS", sizeof buf);
3195 1.57 mjacob }
3196 1.57 mjacob if (sp->req_state_flags & RQSF_GOT_SENSE) {
3197 1.57 mjacob STRNCAT(buf, " GOT_SNS", sizeof buf);
3198 1.57 mjacob }
3199 1.57 mjacob if (sp->req_state_flags & RQSF_XFER_COMPLETE) {
3200 1.57 mjacob STRNCAT(buf, " XFR_CMPLT", sizeof buf);
3201 1.57 mjacob }
3202 1.57 mjacob STRNCAT(buf, "\nstatus=>", sizeof buf);
3203 1.57 mjacob if (sp->req_status_flags & RQSTF_DISCONNECT) {
3204 1.57 mjacob STRNCAT(buf, " Disconnect", sizeof buf);
3205 1.57 mjacob }
3206 1.57 mjacob if (sp->req_status_flags & RQSTF_SYNCHRONOUS) {
3207 1.57 mjacob STRNCAT(buf, " Sync_xfr", sizeof buf);
3208 1.57 mjacob }
3209 1.57 mjacob if (sp->req_status_flags & RQSTF_PARITY_ERROR) {
3210 1.57 mjacob STRNCAT(buf, " Parity", sizeof buf);
3211 1.57 mjacob }
3212 1.57 mjacob if (sp->req_status_flags & RQSTF_BUS_RESET) {
3213 1.57 mjacob STRNCAT(buf, " Bus_Reset", sizeof buf);
3214 1.57 mjacob }
3215 1.57 mjacob if (sp->req_status_flags & RQSTF_DEVICE_RESET) {
3216 1.57 mjacob STRNCAT(buf, " Device_Reset", sizeof buf);
3217 1.57 mjacob }
3218 1.57 mjacob if (sp->req_status_flags & RQSTF_ABORTED) {
3219 1.57 mjacob STRNCAT(buf, " Aborted", sizeof buf);
3220 1.57 mjacob }
3221 1.57 mjacob if (sp->req_status_flags & RQSTF_TIMEOUT) {
3222 1.57 mjacob STRNCAT(buf, " Timeout", sizeof buf);
3223 1.57 mjacob }
3224 1.57 mjacob if (sp->req_status_flags & RQSTF_NEGOTIATION) {
3225 1.57 mjacob STRNCAT(buf, " Negotiation", sizeof buf);
3226 1.57 mjacob }
3227 1.57 mjacob isp_prt(isp, ISP_LOGERR, "%s", buf);
3228 1.57 mjacob isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d:\n%s",
3229 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), buf);
3230 1.15 mjacob break;
3231 1.57 mjacob }
3232 1.25 mjacob case RQCS_RESET_OCCURRED:
3233 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
3234 1.57 mjacob "bus reset destroyed command for %d.%d.%d",
3235 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3236 1.51 mjacob isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
3237 1.57 mjacob if (XS_NOERR(xs)) {
3238 1.57 mjacob XS_SETERR(xs, HBA_BUSRESET);
3239 1.57 mjacob }
3240 1.25 mjacob return;
3241 1.25 mjacob
3242 1.25 mjacob case RQCS_ABORTED:
3243 1.57 mjacob isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d",
3244 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3245 1.51 mjacob isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
3246 1.57 mjacob if (XS_NOERR(xs)) {
3247 1.57 mjacob XS_SETERR(xs, HBA_ABORTED);
3248 1.57 mjacob }
3249 1.25 mjacob return;
3250 1.25 mjacob
3251 1.25 mjacob case RQCS_TIMEOUT:
3252 1.57 mjacob isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
3253 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3254 1.57 mjacob if (XS_NOERR(xs)) {
3255 1.57 mjacob XS_SETERR(xs, HBA_CMDTIMEOUT);
3256 1.57 mjacob }
3257 1.25 mjacob return;
3258 1.25 mjacob
3259 1.10 mjacob case RQCS_DATA_OVERRUN:
3260 1.61 mjacob XS_RESID(xs) = sp->req_resid;
3261 1.57 mjacob isp_prt(isp, ISP_LOGERR, "data overrun for command on %d.%d.%d",
3262 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3263 1.57 mjacob if (XS_NOERR(xs)) {
3264 1.57 mjacob XS_SETERR(xs, HBA_DATAOVR);
3265 1.57 mjacob }
3266 1.23 mjacob return;
3267 1.10 mjacob
3268 1.25 mjacob case RQCS_COMMAND_OVERRUN:
3269 1.57 mjacob isp_prt(isp, ISP_LOGERR,
3270 1.57 mjacob "command overrun for command on %d.%d.%d",
3271 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3272 1.25 mjacob break;
3273 1.25 mjacob
3274 1.25 mjacob case RQCS_STATUS_OVERRUN:
3275 1.57 mjacob isp_prt(isp, ISP_LOGERR,
3276 1.57 mjacob "status overrun for command on %d.%d.%d",
3277 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3278 1.25 mjacob break;
3279 1.25 mjacob
3280 1.25 mjacob case RQCS_BAD_MESSAGE:
3281 1.57 mjacob isp_prt(isp, ISP_LOGERR,
3282 1.57 mjacob "msg not COMMAND COMPLETE after status %d.%d.%d",
3283 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3284 1.25 mjacob break;
3285 1.25 mjacob
3286 1.25 mjacob case RQCS_NO_MESSAGE_OUT:
3287 1.57 mjacob isp_prt(isp, ISP_LOGERR,
3288 1.57 mjacob "No MESSAGE OUT phase after selection on %d.%d.%d",
3289 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3290 1.25 mjacob break;
3291 1.25 mjacob
3292 1.25 mjacob case RQCS_EXT_ID_FAILED:
3293 1.57 mjacob isp_prt(isp, ISP_LOGERR, "EXTENDED IDENTIFY failed %d.%d.%d",
3294 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3295 1.25 mjacob break;
3296 1.25 mjacob
3297 1.25 mjacob case RQCS_IDE_MSG_FAILED:
3298 1.57 mjacob isp_prt(isp, ISP_LOGERR,
3299 1.57 mjacob "INITIATOR DETECTED ERROR rejected by %d.%d.%d",
3300 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3301 1.25 mjacob break;
3302 1.25 mjacob
3303 1.25 mjacob case RQCS_ABORT_MSG_FAILED:
3304 1.57 mjacob isp_prt(isp, ISP_LOGERR, "ABORT OPERATION rejected by %d.%d.%d",
3305 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3306 1.25 mjacob break;
3307 1.25 mjacob
3308 1.25 mjacob case RQCS_REJECT_MSG_FAILED:
3309 1.57 mjacob isp_prt(isp, ISP_LOGERR, "MESSAGE REJECT rejected by %d.%d.%d",
3310 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3311 1.25 mjacob break;
3312 1.25 mjacob
3313 1.25 mjacob case RQCS_NOP_MSG_FAILED:
3314 1.57 mjacob isp_prt(isp, ISP_LOGERR, "NOP rejected by %d.%d.%d",
3315 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3316 1.25 mjacob break;
3317 1.25 mjacob
3318 1.25 mjacob case RQCS_PARITY_ERROR_MSG_FAILED:
3319 1.57 mjacob isp_prt(isp, ISP_LOGERR,
3320 1.57 mjacob "MESSAGE PARITY ERROR rejected by %d.%d.%d",
3321 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3322 1.25 mjacob break;
3323 1.25 mjacob
3324 1.25 mjacob case RQCS_DEVICE_RESET_MSG_FAILED:
3325 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
3326 1.57 mjacob "BUS DEVICE RESET rejected by %d.%d.%d",
3327 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3328 1.25 mjacob break;
3329 1.25 mjacob
3330 1.25 mjacob case RQCS_ID_MSG_FAILED:
3331 1.57 mjacob isp_prt(isp, ISP_LOGERR, "IDENTIFY rejected by %d.%d.%d",
3332 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3333 1.25 mjacob break;
3334 1.25 mjacob
3335 1.25 mjacob case RQCS_UNEXP_BUS_FREE:
3336 1.57 mjacob isp_prt(isp, ISP_LOGERR, "%d.%d.%d had an unexpected bus free",
3337 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3338 1.25 mjacob break;
3339 1.25 mjacob
3340 1.1 cgd case RQCS_DATA_UNDERRUN:
3341 1.61 mjacob XS_RESID(xs) = sp->req_resid;
3342 1.57 mjacob if (XS_NOERR(xs)) {
3343 1.57 mjacob XS_SETERR(xs, HBA_NOERROR);
3344 1.57 mjacob }
3345 1.23 mjacob return;
3346 1.10 mjacob
3347 1.25 mjacob case RQCS_XACT_ERR1:
3348 1.57 mjacob isp_prt(isp, ISP_LOGERR, xact1, XS_CHANNEL(xs),
3349 1.51 mjacob XS_TGT(xs), XS_LUN(xs));
3350 1.25 mjacob break;
3351 1.25 mjacob
3352 1.25 mjacob case RQCS_XACT_ERR2:
3353 1.57 mjacob isp_prt(isp, ISP_LOGERR, xact2,
3354 1.51 mjacob XS_LUN(xs), XS_TGT(xs), XS_CHANNEL(xs));
3355 1.25 mjacob break;
3356 1.25 mjacob
3357 1.25 mjacob case RQCS_XACT_ERR3:
3358 1.57 mjacob isp_prt(isp, ISP_LOGERR, xact3, XS_TGT(xs),
3359 1.57 mjacob XS_LUN(xs), XS_CHANNEL(xs));
3360 1.25 mjacob break;
3361 1.25 mjacob
3362 1.25 mjacob case RQCS_BAD_ENTRY:
3363 1.57 mjacob isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
3364 1.25 mjacob break;
3365 1.25 mjacob
3366 1.25 mjacob case RQCS_QUEUE_FULL:
3367 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG1,
3368 1.57 mjacob "internal queues full for %d.%d.%d status 0x%x", XS_TGT(xs),
3369 1.57 mjacob XS_LUN(xs), XS_CHANNEL(xs), *XS_STSP(xs));
3370 1.30 mjacob /*
3371 1.30 mjacob * If QFULL or some other status byte is set, then this
3372 1.30 mjacob * isn't an error, per se.
3373 1.30 mjacob */
3374 1.57 mjacob if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
3375 1.30 mjacob XS_SETERR(xs, HBA_NOERROR);
3376 1.30 mjacob return;
3377 1.30 mjacob }
3378 1.25 mjacob break;
3379 1.25 mjacob
3380 1.25 mjacob case RQCS_PHASE_SKIPPED:
3381 1.57 mjacob isp_prt(isp, ISP_LOGERR, pskip,
3382 1.57 mjacob XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
3383 1.25 mjacob break;
3384 1.25 mjacob
3385 1.25 mjacob case RQCS_ARQS_FAILED:
3386 1.57 mjacob isp_prt(isp, ISP_LOGERR,
3387 1.57 mjacob "Auto Request Sense failed for %d.%d.%d",
3388 1.57 mjacob XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
3389 1.57 mjacob if (XS_NOERR(xs)) {
3390 1.57 mjacob XS_SETERR(xs, HBA_ARQFAIL);
3391 1.57 mjacob }
3392 1.23 mjacob return;
3393 1.10 mjacob
3394 1.25 mjacob case RQCS_WIDE_FAILED:
3395 1.57 mjacob isp_prt(isp, ISP_LOGERR,
3396 1.57 mjacob "Wide Negotiation failed for %d.%d.%d",
3397 1.57 mjacob XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
3398 1.36 mjacob if (IS_SCSI(isp)) {
3399 1.25 mjacob sdparam *sdp = isp->isp_param;
3400 1.36 mjacob sdp += XS_CHANNEL(xs);
3401 1.31 mjacob sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_WIDE;
3402 1.25 mjacob sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
3403 1.51 mjacob isp->isp_update |= (1 << XS_CHANNEL(xs));
3404 1.25 mjacob }
3405 1.57 mjacob if (XS_NOERR(xs)) {
3406 1.57 mjacob XS_SETERR(xs, HBA_NOERROR);
3407 1.57 mjacob }
3408 1.23 mjacob return;
3409 1.10 mjacob
3410 1.25 mjacob case RQCS_SYNCXFER_FAILED:
3411 1.57 mjacob isp_prt(isp, ISP_LOGERR,
3412 1.57 mjacob "SDTR Message failed for target %d.%d.%d",
3413 1.57 mjacob XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
3414 1.36 mjacob if (IS_SCSI(isp)) {
3415 1.25 mjacob sdparam *sdp = isp->isp_param;
3416 1.36 mjacob sdp += XS_CHANNEL(xs);
3417 1.31 mjacob sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_SYNC;
3418 1.25 mjacob sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
3419 1.51 mjacob isp->isp_update |= (1 << XS_CHANNEL(xs));
3420 1.25 mjacob }
3421 1.25 mjacob break;
3422 1.25 mjacob
3423 1.25 mjacob case RQCS_LVD_BUSERR:
3424 1.57 mjacob isp_prt(isp, ISP_LOGERR,
3425 1.57 mjacob "Bad LVD condition while talking to %d.%d.%d",
3426 1.57 mjacob XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
3427 1.25 mjacob break;
3428 1.10 mjacob
3429 1.10 mjacob case RQCS_PORT_UNAVAILABLE:
3430 1.10 mjacob /*
3431 1.10 mjacob * No such port on the loop. Moral equivalent of SELTIMEO
3432 1.10 mjacob */
3433 1.57 mjacob isp_prt(isp, ISP_LOGINFO,
3434 1.57 mjacob "Port Unavailable for target %d", XS_TGT(xs));
3435 1.57 mjacob if (XS_NOERR(xs)) {
3436 1.57 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
3437 1.57 mjacob }
3438 1.23 mjacob return;
3439 1.10 mjacob
3440 1.10 mjacob case RQCS_PORT_LOGGED_OUT:
3441 1.27 mjacob /*
3442 1.27 mjacob * It was there (maybe)- treat as a selection timeout.
3443 1.27 mjacob */
3444 1.57 mjacob isp_prt(isp, ISP_LOGINFO,
3445 1.57 mjacob "port logout for target %d", XS_TGT(xs));
3446 1.57 mjacob if (XS_NOERR(xs)) {
3447 1.57 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
3448 1.57 mjacob }
3449 1.27 mjacob return;
3450 1.10 mjacob
3451 1.10 mjacob case RQCS_PORT_CHANGED:
3452 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
3453 1.57 mjacob "port changed for target %d", XS_TGT(xs));
3454 1.57 mjacob if (XS_NOERR(xs)) {
3455 1.57 mjacob XS_SETERR(xs, HBA_SELTIMEOUT);
3456 1.57 mjacob }
3457 1.51 mjacob return;
3458 1.10 mjacob
3459 1.10 mjacob case RQCS_PORT_BUSY:
3460 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
3461 1.57 mjacob "port busy for target %d", XS_TGT(xs));
3462 1.57 mjacob if (XS_NOERR(xs)) {
3463 1.57 mjacob XS_SETERR(xs, HBA_TGTBSY);
3464 1.57 mjacob }
3465 1.23 mjacob return;
3466 1.10 mjacob
3467 1.1 cgd default:
3468 1.57 mjacob isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
3469 1.57 mjacob sp->req_completion_status);
3470 1.1 cgd break;
3471 1.1 cgd }
3472 1.57 mjacob if (XS_NOERR(xs)) {
3473 1.57 mjacob XS_SETERR(xs, HBA_BOTCH);
3474 1.57 mjacob }
3475 1.1 cgd }
3476 1.1 cgd
3477 1.33 mjacob static void
3478 1.33 mjacob isp_fastpost_complete(isp, fph)
3479 1.33 mjacob struct ispsoftc *isp;
3480 1.38 mjacob u_int32_t fph;
3481 1.33 mjacob {
3482 1.57 mjacob XS_T *xs;
3483 1.33 mjacob
3484 1.38 mjacob if (fph < 1) {
3485 1.33 mjacob return;
3486 1.38 mjacob }
3487 1.38 mjacob xs = isp_find_xs(isp, fph);
3488 1.33 mjacob if (xs == NULL) {
3489 1.57 mjacob isp_prt(isp, ISP_LOGWARN,
3490 1.57 mjacob "Command for fast post handle 0x%x not found", fph);
3491 1.33 mjacob return;
3492 1.33 mjacob }
3493 1.38 mjacob isp_destroy_handle(isp, fph);
3494 1.38 mjacob
3495 1.33 mjacob /*
3496 1.33 mjacob * Since we don't have a result queue entry item,
3497 1.33 mjacob * we must believe that SCSI status is zero and
3498 1.33 mjacob * that all data transferred.
3499 1.33 mjacob */
3500 1.57 mjacob XS_SET_STATE_STAT(isp, xs, NULL);
3501 1.33 mjacob XS_RESID(xs) = 0;
3502 1.57 mjacob *XS_STSP(xs) = SCSI_GOOD;
3503 1.33 mjacob if (XS_XFRLEN(xs)) {
3504 1.38 mjacob ISP_DMAFREE(isp, xs, fph);
3505 1.33 mjacob }
3506 1.38 mjacob if (isp->isp_nactive)
3507 1.38 mjacob isp->isp_nactive--;
3508 1.60 mjacob isp_done(xs);
3509 1.33 mjacob }
3510 1.33 mjacob
3511 1.54 mjacob #define HIBYT(x) ((x) >> 0x8)
3512 1.54 mjacob #define LOBYT(x) ((x) & 0xff)
3513 1.54 mjacob #define ISPOPMAP(a, b) (((a) << 8) | (b))
3514 1.54 mjacob static u_int16_t mbpscsi[] = {
3515 1.54 mjacob ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
3516 1.54 mjacob ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
3517 1.54 mjacob ISPOPMAP(0x03, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */
3518 1.54 mjacob ISPOPMAP(0x1f, 0x01), /* 0x03: MBOX_DUMP_RAM */
3519 1.54 mjacob ISPOPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
3520 1.54 mjacob ISPOPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
3521 1.54 mjacob ISPOPMAP(0x3f, 0x3f), /* 0x06: MBOX_MAILBOX_REG_TEST */
3522 1.54 mjacob ISPOPMAP(0x03, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */
3523 1.54 mjacob ISPOPMAP(0x01, 0x0f), /* 0x08: MBOX_ABOUT_FIRMWARE */
3524 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x09: */
3525 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x0a: */
3526 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x0b: */
3527 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x0c: */
3528 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x0d: */
3529 1.54 mjacob ISPOPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
3530 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x0f: */
3531 1.54 mjacob ISPOPMAP(0x1f, 0x1f), /* 0x10: MBOX_INIT_REQ_QUEUE */
3532 1.54 mjacob ISPOPMAP(0x3f, 0x3f), /* 0x11: MBOX_INIT_RES_QUEUE */
3533 1.54 mjacob ISPOPMAP(0x0f, 0x0f), /* 0x12: MBOX_EXECUTE_IOCB */
3534 1.54 mjacob ISPOPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */
3535 1.54 mjacob ISPOPMAP(0x01, 0x3f), /* 0x14: MBOX_STOP_FIRMWARE */
3536 1.54 mjacob ISPOPMAP(0x0f, 0x0f), /* 0x15: MBOX_ABORT */
3537 1.54 mjacob ISPOPMAP(0x03, 0x03), /* 0x16: MBOX_ABORT_DEVICE */
3538 1.54 mjacob ISPOPMAP(0x07, 0x07), /* 0x17: MBOX_ABORT_TARGET */
3539 1.54 mjacob ISPOPMAP(0x07, 0x07), /* 0x18: MBOX_BUS_RESET */
3540 1.54 mjacob ISPOPMAP(0x03, 0x07), /* 0x19: MBOX_STOP_QUEUE */
3541 1.54 mjacob ISPOPMAP(0x03, 0x07), /* 0x1a: MBOX_START_QUEUE */
3542 1.54 mjacob ISPOPMAP(0x03, 0x07), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
3543 1.54 mjacob ISPOPMAP(0x03, 0x07), /* 0x1c: MBOX_ABORT_QUEUE */
3544 1.54 mjacob ISPOPMAP(0x03, 0x4f), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
3545 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x1e: */
3546 1.54 mjacob ISPOPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
3547 1.54 mjacob ISPOPMAP(0x01, 0x07), /* 0x20: MBOX_GET_INIT_SCSI_ID */
3548 1.54 mjacob ISPOPMAP(0x01, 0x07), /* 0x21: MBOX_GET_SELECT_TIMEOUT */
3549 1.54 mjacob ISPOPMAP(0x01, 0xc7), /* 0x22: MBOX_GET_RETRY_COUNT */
3550 1.54 mjacob ISPOPMAP(0x01, 0x07), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
3551 1.54 mjacob ISPOPMAP(0x01, 0x03), /* 0x24: MBOX_GET_CLOCK_RATE */
3552 1.54 mjacob ISPOPMAP(0x01, 0x07), /* 0x25: MBOX_GET_ACT_NEG_STATE */
3553 1.54 mjacob ISPOPMAP(0x01, 0x07), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
3554 1.54 mjacob ISPOPMAP(0x01, 0x07), /* 0x27: MBOX_GET_PCI_PARAMS */
3555 1.54 mjacob ISPOPMAP(0x03, 0x4f), /* 0x28: MBOX_GET_TARGET_PARAMS */
3556 1.54 mjacob ISPOPMAP(0x03, 0x0f), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
3557 1.54 mjacob ISPOPMAP(0x01, 0x07), /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */
3558 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x2b: */
3559 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x2c: */
3560 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x2d: */
3561 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x2e: */
3562 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x2f: */
3563 1.54 mjacob ISPOPMAP(0x03, 0x03), /* 0x30: MBOX_SET_INIT_SCSI_ID */
3564 1.54 mjacob ISPOPMAP(0x07, 0x07), /* 0x31: MBOX_SET_SELECT_TIMEOUT */
3565 1.54 mjacob ISPOPMAP(0xc7, 0xc7), /* 0x32: MBOX_SET_RETRY_COUNT */
3566 1.54 mjacob ISPOPMAP(0x07, 0x07), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
3567 1.54 mjacob ISPOPMAP(0x03, 0x03), /* 0x34: MBOX_SET_CLOCK_RATE */
3568 1.54 mjacob ISPOPMAP(0x07, 0x07), /* 0x35: MBOX_SET_ACT_NEG_STATE */
3569 1.54 mjacob ISPOPMAP(0x07, 0x07), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
3570 1.54 mjacob ISPOPMAP(0x07, 0x07), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
3571 1.54 mjacob ISPOPMAP(0x4f, 0x4f), /* 0x38: MBOX_SET_TARGET_PARAMS */
3572 1.54 mjacob ISPOPMAP(0x0f, 0x0f), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
3573 1.54 mjacob ISPOPMAP(0x07, 0x07), /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */
3574 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x3b: */
3575 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x3c: */
3576 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x3d: */
3577 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x3e: */
3578 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x3f: */
3579 1.54 mjacob ISPOPMAP(0x01, 0x03), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
3580 1.54 mjacob ISPOPMAP(0x3f, 0x01), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
3581 1.54 mjacob ISPOPMAP(0x03, 0x07), /* 0x42: MBOX_EXEC_BIOS_IOCB */
3582 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x43: */
3583 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x44: */
3584 1.54 mjacob ISPOPMAP(0x03, 0x03), /* 0x45: SET SYSTEM PARAMETER */
3585 1.54 mjacob ISPOPMAP(0x01, 0x03), /* 0x46: GET SYSTEM PARAMETER */
3586 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x47: */
3587 1.54 mjacob ISPOPMAP(0x01, 0xcf), /* 0x48: GET SCAM CONFIGURATION */
3588 1.54 mjacob ISPOPMAP(0xcf, 0xcf), /* 0x49: SET SCAM CONFIGURATION */
3589 1.54 mjacob ISPOPMAP(0x03, 0x03), /* 0x4a: MBOX_SET_FIRMWARE_FEATURES */
3590 1.54 mjacob ISPOPMAP(0x01, 0x03), /* 0x4b: MBOX_GET_FIRMWARE_FEATURES */
3591 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x4c: */
3592 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x4d: */
3593 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x4e: */
3594 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x4f: */
3595 1.54 mjacob ISPOPMAP(0xdf, 0xdf), /* 0x50: LOAD RAM A64 */
3596 1.54 mjacob ISPOPMAP(0xdf, 0xdf), /* 0x51: DUMP RAM A64 */
3597 1.54 mjacob ISPOPMAP(0xdf, 0xdf), /* 0x52: INITIALIZE REQUEST QUEUE A64 */
3598 1.54 mjacob ISPOPMAP(0xff, 0xff), /* 0x53: INITIALIZE RESPONSE QUEUE A64 */
3599 1.54 mjacob ISPOPMAP(0xcf, 0xff), /* 0x54: EXECUTE IOCB A64 */
3600 1.54 mjacob ISPOPMAP(0x03, 0x01), /* 0x55: ENABLE TARGET MODE */
3601 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x56: */
3602 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x57: */
3603 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x58: */
3604 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x59: */
3605 1.54 mjacob ISPOPMAP(0x03, 0x03), /* 0x5a: SET DATA OVERRUN RECOVERY MODE */
3606 1.54 mjacob ISPOPMAP(0x01, 0x03), /* 0x5b: GET DATA OVERRUN RECOVERY MODE */
3607 1.54 mjacob ISPOPMAP(0x0f, 0x0f), /* 0x5c: SET HOST DATA */
3608 1.54 mjacob ISPOPMAP(0x01, 0x01) /* 0x5d: GET NOST DATA */
3609 1.54 mjacob };
3610 1.54 mjacob
3611 1.57 mjacob #ifndef ISP_STRIPEED
3612 1.57 mjacob static char *scsi_mbcmd_names[] = {
3613 1.57 mjacob "NO-OP",
3614 1.57 mjacob "LOAD RAM",
3615 1.57 mjacob "EXEC FIRMWARE",
3616 1.57 mjacob "DUMP RAM",
3617 1.57 mjacob "WRITE RAM WORD",
3618 1.57 mjacob "READ RAM WORD",
3619 1.57 mjacob "MAILBOX REG TEST",
3620 1.57 mjacob "VERIFY CHECKSUM",
3621 1.57 mjacob "ABOUT FIRMWARE",
3622 1.57 mjacob NULL,
3623 1.57 mjacob NULL,
3624 1.57 mjacob NULL,
3625 1.57 mjacob NULL,
3626 1.57 mjacob NULL,
3627 1.57 mjacob "CHECK FIRMWARE",
3628 1.57 mjacob NULL,
3629 1.57 mjacob "INIT REQUEST QUEUE",
3630 1.57 mjacob "INIT RESULT QUEUE",
3631 1.57 mjacob "EXECUTE IOCB",
3632 1.57 mjacob "WAKE UP",
3633 1.57 mjacob "STOP FIRMWARE",
3634 1.57 mjacob "ABORT",
3635 1.57 mjacob "ABORT DEVICE",
3636 1.57 mjacob "ABORT TARGET",
3637 1.57 mjacob "BUS RESET",
3638 1.57 mjacob "STOP QUEUE",
3639 1.57 mjacob "START QUEUE",
3640 1.57 mjacob "SINGLE STEP QUEUE",
3641 1.57 mjacob "ABORT QUEUE",
3642 1.57 mjacob "GET DEV QUEUE STATUS",
3643 1.57 mjacob NULL,
3644 1.57 mjacob "GET FIRMWARE STATUS",
3645 1.57 mjacob "GET INIT SCSI ID",
3646 1.57 mjacob "GET SELECT TIMEOUT",
3647 1.57 mjacob "GET RETRY COUNT",
3648 1.57 mjacob "GET TAG AGE LIMIT",
3649 1.57 mjacob "GET CLOCK RATE",
3650 1.57 mjacob "GET ACT NEG STATE",
3651 1.57 mjacob "GET ASYNC DATA SETUP TIME",
3652 1.57 mjacob "GET PCI PARAMS",
3653 1.57 mjacob "GET TARGET PARAMS",
3654 1.57 mjacob "GET DEV QUEUE PARAMS",
3655 1.57 mjacob "GET RESET DELAY PARAMS",
3656 1.57 mjacob NULL,
3657 1.57 mjacob NULL,
3658 1.57 mjacob NULL,
3659 1.57 mjacob NULL,
3660 1.57 mjacob NULL,
3661 1.57 mjacob "SET INIT SCSI ID",
3662 1.57 mjacob "SET SELECT TIMEOUT",
3663 1.57 mjacob "SET RETRY COUNT",
3664 1.57 mjacob "SET TAG AGE LIMIT",
3665 1.57 mjacob "SET CLOCK RATE",
3666 1.57 mjacob "SET ACT NEG STATE",
3667 1.57 mjacob "SET ASYNC DATA SETUP TIME",
3668 1.57 mjacob "SET PCI CONTROL PARAMS",
3669 1.57 mjacob "SET TARGET PARAMS",
3670 1.57 mjacob "SET DEV QUEUE PARAMS",
3671 1.57 mjacob "SET RESET DELAY PARAMS",
3672 1.57 mjacob NULL,
3673 1.57 mjacob NULL,
3674 1.57 mjacob NULL,
3675 1.57 mjacob NULL,
3676 1.57 mjacob NULL,
3677 1.57 mjacob "RETURN BIOS BLOCK ADDR",
3678 1.57 mjacob "WRITE FOUR RAM WORDS",
3679 1.57 mjacob "EXEC BIOS IOCB",
3680 1.57 mjacob NULL,
3681 1.57 mjacob NULL,
3682 1.57 mjacob "SET SYSTEM PARAMETER",
3683 1.57 mjacob "GET SYSTEM PARAMETER",
3684 1.57 mjacob NULL,
3685 1.57 mjacob "GET SCAM CONFIGURATION",
3686 1.57 mjacob "SET SCAM CONFIGURATION",
3687 1.57 mjacob "SET FIRMWARE FEATURES",
3688 1.57 mjacob "GET FIRMWARE FEATURES",
3689 1.57 mjacob NULL,
3690 1.57 mjacob NULL,
3691 1.57 mjacob NULL,
3692 1.57 mjacob NULL,
3693 1.57 mjacob "LOAD RAM A64",
3694 1.57 mjacob "DUMP RAM A64",
3695 1.57 mjacob "INITIALIZE REQUEST QUEUE A64",
3696 1.57 mjacob "INITIALIZE RESPONSE QUEUE A64",
3697 1.57 mjacob "EXECUTE IOCB A64",
3698 1.57 mjacob "ENABLE TARGET MODE",
3699 1.57 mjacob NULL,
3700 1.57 mjacob NULL,
3701 1.57 mjacob NULL,
3702 1.57 mjacob NULL,
3703 1.57 mjacob "SET DATA OVERRUN RECOVERY MODE",
3704 1.57 mjacob "GET DATA OVERRUN RECOVERY MODE",
3705 1.57 mjacob "SET HOST DATA",
3706 1.57 mjacob "GET NOST DATA",
3707 1.57 mjacob };
3708 1.57 mjacob #endif
3709 1.57 mjacob
3710 1.54 mjacob static u_int16_t mbpfc[] = {
3711 1.54 mjacob ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
3712 1.54 mjacob ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
3713 1.54 mjacob ISPOPMAP(0x03, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */
3714 1.54 mjacob ISPOPMAP(0x1f, 0x01), /* 0x03: MBOX_DUMP_RAM */
3715 1.54 mjacob ISPOPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
3716 1.54 mjacob ISPOPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
3717 1.54 mjacob ISPOPMAP(0xff, 0xff), /* 0x06: MBOX_MAILBOX_REG_TEST */
3718 1.54 mjacob ISPOPMAP(0x03, 0x05), /* 0x07: MBOX_VERIFY_CHECKSUM */
3719 1.54 mjacob ISPOPMAP(0x01, 0x0f), /* 0x08: MBOX_ABOUT_FIRMWARE */
3720 1.54 mjacob ISPOPMAP(0xdf, 0x01), /* 0x09: LOAD RAM */
3721 1.54 mjacob ISPOPMAP(0xdf, 0x01), /* 0x0a: DUMP RAM */
3722 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x0b: */
3723 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x0c: */
3724 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x0d: */
3725 1.54 mjacob ISPOPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
3726 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x0f: */
3727 1.54 mjacob ISPOPMAP(0x1f, 0x11), /* 0x10: MBOX_INIT_REQ_QUEUE */
3728 1.54 mjacob ISPOPMAP(0x2f, 0x21), /* 0x11: MBOX_INIT_RES_QUEUE */
3729 1.54 mjacob ISPOPMAP(0x0f, 0x01), /* 0x12: MBOX_EXECUTE_IOCB */
3730 1.54 mjacob ISPOPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */
3731 1.54 mjacob ISPOPMAP(0x01, 0xff), /* 0x14: MBOX_STOP_FIRMWARE */
3732 1.54 mjacob ISPOPMAP(0x4f, 0x01), /* 0x15: MBOX_ABORT */
3733 1.54 mjacob ISPOPMAP(0x07, 0x01), /* 0x16: MBOX_ABORT_DEVICE */
3734 1.54 mjacob ISPOPMAP(0x07, 0x01), /* 0x17: MBOX_ABORT_TARGET */
3735 1.54 mjacob ISPOPMAP(0x03, 0x03), /* 0x18: MBOX_BUS_RESET */
3736 1.54 mjacob ISPOPMAP(0x07, 0x05), /* 0x19: MBOX_STOP_QUEUE */
3737 1.54 mjacob ISPOPMAP(0x07, 0x05), /* 0x1a: MBOX_START_QUEUE */
3738 1.54 mjacob ISPOPMAP(0x07, 0x05), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
3739 1.54 mjacob ISPOPMAP(0x07, 0x05), /* 0x1c: MBOX_ABORT_QUEUE */
3740 1.54 mjacob ISPOPMAP(0x07, 0x03), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
3741 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x1e: */
3742 1.54 mjacob ISPOPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
3743 1.54 mjacob ISPOPMAP(0x01, 0x4f), /* 0x20: MBOX_GET_LOOP_ID */
3744 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x21: */
3745 1.54 mjacob ISPOPMAP(0x01, 0x07), /* 0x22: MBOX_GET_RETRY_COUNT */
3746 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x23: */
3747 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x24: */
3748 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x25: */
3749 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x26: */
3750 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x27: */
3751 1.54 mjacob ISPOPMAP(0x0f, 0x1), /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */
3752 1.54 mjacob ISPOPMAP(0x03, 0x07), /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */
3753 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x2a: */
3754 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x2b: */
3755 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x2c: */
3756 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x2d: */
3757 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x2e: */
3758 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x2f: */
3759 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x30: */
3760 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x31: */
3761 1.54 mjacob ISPOPMAP(0x07, 0x07), /* 0x32: MBOX_SET_RETRY_COUNT */
3762 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x33: */
3763 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x34: */
3764 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x35: */
3765 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x36: */
3766 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x37: */
3767 1.54 mjacob ISPOPMAP(0x0f, 0x01), /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */
3768 1.54 mjacob ISPOPMAP(0x0f, 0x07), /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */
3769 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x3a: */
3770 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x3b: */
3771 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x3c: */
3772 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x3d: */
3773 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x3e: */
3774 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x3f: */
3775 1.54 mjacob ISPOPMAP(0x03, 0x01), /* 0x40: MBOX_LOOP_PORT_BYPASS */
3776 1.54 mjacob ISPOPMAP(0x03, 0x01), /* 0x41: MBOX_LOOP_PORT_ENABLE */
3777 1.54 mjacob ISPOPMAP(0x03, 0x07), /* 0x42: MBOX_GET_RESOURCE_COUNTS */
3778 1.54 mjacob ISPOPMAP(0x01, 0x01), /* 0x43: MBOX_REQUEST_NON_PARTICIPATING_MODE */
3779 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x44: */
3780 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x45: */
3781 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x46: */
3782 1.54 mjacob ISPOPMAP(0xcf, 0x03), /* 0x47: GET PORT_DATABASE ENHANCED */
3783 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x48: */
3784 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x49: */
3785 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x4a: */
3786 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x4b: */
3787 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x4c: */
3788 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x4d: */
3789 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x4e: */
3790 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x4f: */
3791 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x50: */
3792 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x51: */
3793 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x52: */
3794 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x53: */
3795 1.54 mjacob ISPOPMAP(0xcf, 0x01), /* 0x54: EXECUTE IOCB A64 */
3796 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x55: */
3797 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x56: */
3798 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x57: */
3799 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x58: */
3800 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x59: */
3801 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x5a: */
3802 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x5b: */
3803 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x5c: */
3804 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x5d: */
3805 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x5e: */
3806 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x5f: */
3807 1.54 mjacob ISPOPMAP(0xfd, 0x31), /* 0x60: MBOX_INIT_FIRMWARE */
3808 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x61: */
3809 1.54 mjacob ISPOPMAP(0x01, 0x01), /* 0x62: MBOX_INIT_LIP */
3810 1.54 mjacob ISPOPMAP(0xcd, 0x03), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
3811 1.54 mjacob ISPOPMAP(0xcf, 0x01), /* 0x64: MBOX_GET_PORT_DB */
3812 1.54 mjacob ISPOPMAP(0x07, 0x01), /* 0x65: MBOX_CLEAR_ACA */
3813 1.54 mjacob ISPOPMAP(0x07, 0x01), /* 0x66: MBOX_TARGET_RESET */
3814 1.54 mjacob ISPOPMAP(0x07, 0x01), /* 0x67: MBOX_CLEAR_TASK_SET */
3815 1.54 mjacob ISPOPMAP(0x07, 0x01), /* 0x68: MBOX_ABORT_TASK_SET */
3816 1.54 mjacob ISPOPMAP(0x01, 0x07), /* 0x69: MBOX_GET_FW_STATE */
3817 1.54 mjacob ISPOPMAP(0x03, 0xcf), /* 0x6a: MBOX_GET_PORT_NAME */
3818 1.54 mjacob ISPOPMAP(0xcf, 0x01), /* 0x6b: MBOX_GET_LINK_STATUS */
3819 1.54 mjacob ISPOPMAP(0x0f, 0x01), /* 0x6c: MBOX_INIT_LIP_RESET */
3820 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x6d: */
3821 1.54 mjacob ISPOPMAP(0xcf, 0x03), /* 0x6e: MBOX_SEND_SNS */
3822 1.54 mjacob ISPOPMAP(0x0f, 0x07), /* 0x6f: MBOX_FABRIC_LOGIN */
3823 1.54 mjacob ISPOPMAP(0x03, 0x01), /* 0x70: MBOX_SEND_CHANGE_REQUEST */
3824 1.54 mjacob ISPOPMAP(0x03, 0x03), /* 0x71: MBOX_FABRIC_LOGOUT */
3825 1.54 mjacob ISPOPMAP(0x0f, 0x0f), /* 0x72: MBOX_INIT_LIP_LOGIN */
3826 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x73: */
3827 1.54 mjacob ISPOPMAP(0x07, 0x01), /* 0x74: LOGIN LOOP PORT */
3828 1.54 mjacob ISPOPMAP(0xcf, 0x03), /* 0x75: GET PORT/NODE NAME LIST */
3829 1.54 mjacob ISPOPMAP(0x4f, 0x01), /* 0x76: SET VENDOR ID */
3830 1.54 mjacob ISPOPMAP(0xcd, 0x01), /* 0x77: INITIALIZE IP MAILBOX */
3831 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x78: */
3832 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x79: */
3833 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x7a: */
3834 1.54 mjacob ISPOPMAP(0x00, 0x00), /* 0x7b: */
3835 1.54 mjacob ISPOPMAP(0x4f, 0x03), /* 0x7c: Get ID List */
3836 1.54 mjacob ISPOPMAP(0xcf, 0x01), /* 0x7d: SEND LFA */
3837 1.54 mjacob ISPOPMAP(0x07, 0x01) /* 0x7e: Lun RESET */
3838 1.1 cgd };
3839 1.1 cgd
3840 1.57 mjacob #ifndef ISP_STRIPPED
3841 1.57 mjacob static char *fc_mbcmd_names[] = {
3842 1.57 mjacob "NO-OP",
3843 1.57 mjacob "LOAD RAM",
3844 1.57 mjacob "EXEC FIRMWARE",
3845 1.57 mjacob "DUMP RAM",
3846 1.57 mjacob "WRITE RAM WORD",
3847 1.57 mjacob "READ RAM WORD",
3848 1.57 mjacob "MAILBOX REG TEST",
3849 1.57 mjacob "VERIFY CHECKSUM",
3850 1.57 mjacob "ABOUT FIRMWARE",
3851 1.57 mjacob "LOAD RAM",
3852 1.57 mjacob "DUMP RAM",
3853 1.57 mjacob NULL,
3854 1.57 mjacob NULL,
3855 1.57 mjacob NULL,
3856 1.57 mjacob "CHECK FIRMWARE",
3857 1.57 mjacob NULL,
3858 1.57 mjacob "INIT REQUEST QUEUE",
3859 1.57 mjacob "INIT RESULT QUEUE",
3860 1.57 mjacob "EXECUTE IOCB",
3861 1.57 mjacob "WAKE UP",
3862 1.57 mjacob "STOP FIRMWARE",
3863 1.57 mjacob "ABORT",
3864 1.57 mjacob "ABORT DEVICE",
3865 1.57 mjacob "ABORT TARGET",
3866 1.57 mjacob "BUS RESET",
3867 1.57 mjacob "STOP QUEUE",
3868 1.57 mjacob "START QUEUE",
3869 1.57 mjacob "SINGLE STEP QUEUE",
3870 1.57 mjacob "ABORT QUEUE",
3871 1.57 mjacob "GET DEV QUEUE STATUS",
3872 1.57 mjacob NULL,
3873 1.57 mjacob "GET FIRMWARE STATUS",
3874 1.57 mjacob "GET LOOP ID",
3875 1.57 mjacob NULL,
3876 1.57 mjacob "GET RETRY COUNT",
3877 1.57 mjacob NULL,
3878 1.57 mjacob NULL,
3879 1.57 mjacob NULL,
3880 1.57 mjacob NULL,
3881 1.57 mjacob NULL,
3882 1.57 mjacob "GET FIRMWARE OPTIONS",
3883 1.57 mjacob "GET PORT QUEUE PARAMS",
3884 1.57 mjacob NULL,
3885 1.57 mjacob NULL,
3886 1.57 mjacob NULL,
3887 1.57 mjacob NULL,
3888 1.57 mjacob NULL,
3889 1.57 mjacob NULL,
3890 1.57 mjacob NULL,
3891 1.57 mjacob NULL,
3892 1.57 mjacob "SET RETRY COUNT",
3893 1.57 mjacob NULL,
3894 1.57 mjacob NULL,
3895 1.57 mjacob NULL,
3896 1.57 mjacob NULL,
3897 1.57 mjacob NULL,
3898 1.57 mjacob "SET FIRMWARE OPTIONS",
3899 1.57 mjacob "SET PORT QUEUE PARAMS",
3900 1.57 mjacob NULL,
3901 1.57 mjacob NULL,
3902 1.57 mjacob NULL,
3903 1.57 mjacob NULL,
3904 1.57 mjacob NULL,
3905 1.57 mjacob NULL,
3906 1.57 mjacob "LOOP PORT BYPASS",
3907 1.57 mjacob "LOOP PORT ENABLE",
3908 1.57 mjacob "GET RESOURCE COUNTS",
3909 1.57 mjacob "REQUEST NON PARTICIPATING MODE",
3910 1.57 mjacob NULL,
3911 1.57 mjacob NULL,
3912 1.57 mjacob NULL,
3913 1.57 mjacob "GET PORT DATABASE,, ENHANCED",
3914 1.57 mjacob NULL,
3915 1.57 mjacob NULL,
3916 1.57 mjacob NULL,
3917 1.57 mjacob NULL,
3918 1.57 mjacob NULL,
3919 1.57 mjacob NULL,
3920 1.57 mjacob NULL,
3921 1.57 mjacob NULL,
3922 1.57 mjacob NULL,
3923 1.57 mjacob NULL,
3924 1.57 mjacob NULL,
3925 1.57 mjacob NULL,
3926 1.57 mjacob "EXECUTE IOCB A64",
3927 1.57 mjacob NULL,
3928 1.57 mjacob NULL,
3929 1.57 mjacob NULL,
3930 1.57 mjacob NULL,
3931 1.57 mjacob NULL,
3932 1.57 mjacob NULL,
3933 1.57 mjacob NULL,
3934 1.57 mjacob NULL,
3935 1.57 mjacob NULL,
3936 1.57 mjacob NULL,
3937 1.57 mjacob NULL,
3938 1.57 mjacob "INIT FIRMWARE",
3939 1.57 mjacob NULL,
3940 1.57 mjacob "INIT LIP",
3941 1.57 mjacob "GET FC-AL POSITION MAP",
3942 1.57 mjacob "GET PORT DATABASE",
3943 1.57 mjacob "CLEAR ACA",
3944 1.57 mjacob "TARGET RESET",
3945 1.57 mjacob "CLEAR TASK SET",
3946 1.57 mjacob "ABORT TASK SET",
3947 1.57 mjacob "GET FW STATE",
3948 1.57 mjacob "GET PORT NAME",
3949 1.57 mjacob "GET LINK STATUS",
3950 1.57 mjacob "INIT LIP RESET",
3951 1.57 mjacob NULL,
3952 1.57 mjacob "SEND SNS",
3953 1.57 mjacob "FABRIC LOGIN",
3954 1.57 mjacob "SEND CHANGE REQUEST",
3955 1.57 mjacob "FABRIC LOGOUT",
3956 1.57 mjacob "INIT LIP LOGIN",
3957 1.57 mjacob NULL,
3958 1.57 mjacob "LOGIN LOOP PORT",
3959 1.57 mjacob "GET PORT/NODE NAME LIST",
3960 1.57 mjacob "SET VENDOR ID",
3961 1.57 mjacob "INITIALIZE IP MAILBOX",
3962 1.57 mjacob NULL,
3963 1.57 mjacob NULL,
3964 1.57 mjacob NULL,
3965 1.57 mjacob NULL,
3966 1.57 mjacob "Get ID List",
3967 1.57 mjacob "SEND LFA",
3968 1.57 mjacob "Lun RESET"
3969 1.57 mjacob };
3970 1.57 mjacob #endif
3971 1.57 mjacob
3972 1.10 mjacob static void
3973 1.57 mjacob isp_mboxcmd(isp, mbp, logmask)
3974 1.1 cgd struct ispsoftc *isp;
3975 1.1 cgd mbreg_t *mbp;
3976 1.57 mjacob int logmask;
3977 1.1 cgd {
3978 1.57 mjacob char *cname, *xname, tname[16], mname[16];
3979 1.54 mjacob unsigned int lim, ibits, obits, box, opcode;
3980 1.54 mjacob u_int16_t *mcp;
3981 1.54 mjacob
3982 1.54 mjacob if (IS_FC(isp)) {
3983 1.54 mjacob mcp = mbpfc;
3984 1.54 mjacob lim = (sizeof (mbpfc) / sizeof (mbpfc[0]));
3985 1.54 mjacob } else {
3986 1.54 mjacob mcp = mbpscsi;
3987 1.54 mjacob lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0]));
3988 1.1 cgd }
3989 1.1 cgd
3990 1.54 mjacob if ((opcode = mbp->param[0]) >= lim) {
3991 1.54 mjacob mbp->param[0] = MBOX_INVALID_COMMAND;
3992 1.57 mjacob isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
3993 1.10 mjacob return;
3994 1.1 cgd }
3995 1.1 cgd
3996 1.54 mjacob ibits = HIBYT(mcp[opcode]) & NMBOX_BMASK(isp);
3997 1.54 mjacob obits = LOBYT(mcp[opcode]) & NMBOX_BMASK(isp);
3998 1.10 mjacob
3999 1.54 mjacob if (ibits == 0 && obits == 0) {
4000 1.54 mjacob mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
4001 1.57 mjacob isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
4002 1.54 mjacob return;
4003 1.28 mjacob }
4004 1.24 mjacob
4005 1.57 mjacob /*
4006 1.57 mjacob * Get exclusive usage of mailbox registers.
4007 1.57 mjacob */
4008 1.57 mjacob MBOX_ACQUIRE(isp);
4009 1.57 mjacob
4010 1.54 mjacob for (box = 0; box < MAX_MAILBOX; box++) {
4011 1.54 mjacob if (ibits & (1 << box)) {
4012 1.54 mjacob ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
4013 1.1 cgd }
4014 1.54 mjacob isp->isp_mboxtmp[box] = mbp->param[box] = 0;
4015 1.1 cgd }
4016 1.1 cgd
4017 1.1 cgd /*
4018 1.54 mjacob * We assume that we can't overwrite a previous command.
4019 1.34 mjacob */
4020 1.54 mjacob isp->isp_mboxbsy = obits;
4021 1.1 cgd
4022 1.1 cgd /*
4023 1.1 cgd * Set Host Interrupt condition so that RISC will pick up mailbox regs.
4024 1.1 cgd */
4025 1.1 cgd ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
4026 1.1 cgd
4027 1.33 mjacob /*
4028 1.54 mjacob * Give the f/w a chance to pick this up.
4029 1.33 mjacob */
4030 1.57 mjacob USEC_DELAY(250);
4031 1.1 cgd
4032 1.1 cgd
4033 1.33 mjacob /*
4034 1.54 mjacob * While we haven't finished the command, spin our wheels here.
4035 1.33 mjacob */
4036 1.54 mjacob MBOX_WAIT_COMPLETE(isp);
4037 1.1 cgd
4038 1.1 cgd /*
4039 1.54 mjacob * Copy back output registers.
4040 1.1 cgd */
4041 1.54 mjacob for (box = 0; box < MAX_MAILBOX; box++) {
4042 1.54 mjacob if (obits & (1 << box)) {
4043 1.54 mjacob mbp->param[box] = isp->isp_mboxtmp[box];
4044 1.36 mjacob }
4045 1.36 mjacob }
4046 1.36 mjacob
4047 1.57 mjacob MBOX_RELEASE(isp);
4048 1.57 mjacob
4049 1.57 mjacob if (logmask == 0 || opcode == MBOX_EXEC_FIRMWARE) {
4050 1.57 mjacob return;
4051 1.57 mjacob }
4052 1.57 mjacob #ifdef ISP_STRIPPED
4053 1.57 mjacob cname = NULL;
4054 1.57 mjacob #else
4055 1.57 mjacob cname = (IS_FC(isp))? fc_mbcmd_names[opcode] : scsi_mbcmd_names[opcode];
4056 1.57 mjacob #endif
4057 1.57 mjacob if (cname == NULL) {
4058 1.57 mjacob SNPRINTF(cname, sizeof tname, "opcode %x", opcode);
4059 1.57 mjacob }
4060 1.57 mjacob
4061 1.10 mjacob /*
4062 1.10 mjacob * Just to be chatty here...
4063 1.10 mjacob */
4064 1.57 mjacob xname = NULL;
4065 1.34 mjacob switch (mbp->param[0]) {
4066 1.10 mjacob case MBOX_COMMAND_COMPLETE:
4067 1.10 mjacob break;
4068 1.10 mjacob case MBOX_INVALID_COMMAND:
4069 1.57 mjacob if (logmask & MBLOGMASK(MBOX_COMMAND_COMPLETE))
4070 1.57 mjacob xname = "INVALID COMMAND";
4071 1.10 mjacob break;
4072 1.10 mjacob case MBOX_HOST_INTERFACE_ERROR:
4073 1.57 mjacob if (logmask & MBLOGMASK(MBOX_HOST_INTERFACE_ERROR))
4074 1.57 mjacob xname = "HOST INTERFACE ERROR";
4075 1.10 mjacob break;
4076 1.10 mjacob case MBOX_TEST_FAILED:
4077 1.57 mjacob if (logmask & MBLOGMASK(MBOX_TEST_FAILED))
4078 1.57 mjacob xname = "TEST FAILED";
4079 1.10 mjacob break;
4080 1.10 mjacob case MBOX_COMMAND_ERROR:
4081 1.57 mjacob if (logmask & MBLOGMASK(MBOX_COMMAND_ERROR))
4082 1.57 mjacob xname = "COMMAND ERROR";
4083 1.10 mjacob break;
4084 1.10 mjacob case MBOX_COMMAND_PARAM_ERROR:
4085 1.57 mjacob if (logmask & MBLOGMASK(MBOX_COMMAND_PARAM_ERROR))
4086 1.57 mjacob xname = "COMMAND PARAMETER ERROR";
4087 1.10 mjacob break;
4088 1.50 mjacob case MBOX_LOOP_ID_USED:
4089 1.57 mjacob if (logmask & MBLOGMASK(MBOX_LOOP_ID_USED))
4090 1.57 mjacob xname = "LOOP ID ALREADY IN USE";
4091 1.57 mjacob break;
4092 1.50 mjacob case MBOX_PORT_ID_USED:
4093 1.57 mjacob if (logmask & MBLOGMASK(MBOX_PORT_ID_USED))
4094 1.57 mjacob xname = "PORT ID ALREADY IN USE";
4095 1.57 mjacob break;
4096 1.50 mjacob case MBOX_ALL_IDS_USED:
4097 1.57 mjacob if (logmask & MBLOGMASK(MBOX_ALL_IDS_USED))
4098 1.57 mjacob xname = "ALL LOOP IDS IN USE";
4099 1.57 mjacob break;
4100 1.57 mjacob case 0: /* special case */
4101 1.57 mjacob xname = "TIMEOUT";
4102 1.50 mjacob break;
4103 1.10 mjacob default:
4104 1.57 mjacob SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
4105 1.57 mjacob xname = mname;
4106 1.10 mjacob break;
4107 1.10 mjacob }
4108 1.57 mjacob if (xname)
4109 1.57 mjacob isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s)",
4110 1.57 mjacob cname, xname);
4111 1.10 mjacob }
4112 1.10 mjacob
4113 1.10 mjacob static void
4114 1.25 mjacob isp_fw_state(isp)
4115 1.25 mjacob struct ispsoftc *isp;
4116 1.10 mjacob {
4117 1.38 mjacob if (IS_FC(isp)) {
4118 1.57 mjacob mbreg_t mbs;
4119 1.10 mjacob fcparam *fcp = isp->isp_param;
4120 1.57 mjacob
4121 1.10 mjacob mbs.param[0] = MBOX_GET_FW_STATE;
4122 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
4123 1.57 mjacob if (mbs.param[0] == MBOX_COMMAND_COMPLETE)
4124 1.57 mjacob fcp->isp_fwstate = mbs.param[1];
4125 1.10 mjacob }
4126 1.10 mjacob }
4127 1.10 mjacob
4128 1.10 mjacob static void
4129 1.25 mjacob isp_update(isp)
4130 1.25 mjacob struct ispsoftc *isp;
4131 1.10 mjacob {
4132 1.58 mjacob int bus, upmask;
4133 1.36 mjacob
4134 1.58 mjacob for (bus = 0, upmask = isp->isp_update; upmask != 0; bus++) {
4135 1.58 mjacob if (upmask & (1 << bus)) {
4136 1.36 mjacob isp_update_bus(isp, bus);
4137 1.36 mjacob }
4138 1.60 mjacob upmask &= ~(1 << bus);
4139 1.36 mjacob }
4140 1.36 mjacob }
4141 1.36 mjacob
4142 1.36 mjacob static void
4143 1.36 mjacob isp_update_bus(isp, bus)
4144 1.36 mjacob struct ispsoftc *isp;
4145 1.36 mjacob int bus;
4146 1.36 mjacob {
4147 1.25 mjacob int tgt;
4148 1.10 mjacob mbreg_t mbs;
4149 1.10 mjacob sdparam *sdp;
4150 1.10 mjacob
4151 1.60 mjacob isp->isp_update &= ~(1 << bus);
4152 1.38 mjacob if (IS_FC(isp)) {
4153 1.58 mjacob /*
4154 1.58 mjacob * There are no 'per-bus' settings for Fibre Channel.
4155 1.58 mjacob */
4156 1.4 mjacob return;
4157 1.4 mjacob }
4158 1.25 mjacob sdp = isp->isp_param;
4159 1.36 mjacob sdp += bus;
4160 1.36 mjacob
4161 1.25 mjacob for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
4162 1.36 mjacob u_int16_t flags, period, offset;
4163 1.31 mjacob int get;
4164 1.31 mjacob
4165 1.25 mjacob if (sdp->isp_devparam[tgt].dev_enable == 0) {
4166 1.60 mjacob sdp->isp_devparam[tgt].dev_update = 0;
4167 1.60 mjacob sdp->isp_devparam[tgt].dev_refresh = 0;
4168 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG1,
4169 1.57 mjacob "skipping target %d bus %d update", tgt, bus);
4170 1.25 mjacob continue;
4171 1.25 mjacob }
4172 1.34 mjacob /*
4173 1.34 mjacob * If the goal is to update the status of the device,
4174 1.34 mjacob * take what's in dev_flags and try and set the device
4175 1.34 mjacob * toward that. Otherwise, if we're just refreshing the
4176 1.34 mjacob * current device state, get the current parameters.
4177 1.34 mjacob */
4178 1.58 mjacob
4179 1.58 mjacob /*
4180 1.58 mjacob * Refresh overrides set
4181 1.58 mjacob */
4182 1.58 mjacob if (sdp->isp_devparam[tgt].dev_refresh) {
4183 1.58 mjacob mbs.param[0] = MBOX_GET_TARGET_PARAMS;
4184 1.58 mjacob sdp->isp_devparam[tgt].dev_refresh = 0;
4185 1.58 mjacob get = 1;
4186 1.58 mjacob } else if (sdp->isp_devparam[tgt].dev_update) {
4187 1.31 mjacob mbs.param[0] = MBOX_SET_TARGET_PARAMS;
4188 1.58 mjacob /*
4189 1.58 mjacob * Make sure dev_flags has "Renegotiate on Error"
4190 1.58 mjacob * on and "Freeze Queue on Error" off.
4191 1.58 mjacob */
4192 1.58 mjacob sdp->isp_devparam[tgt].dev_flags |= DPARM_RENEG;
4193 1.58 mjacob sdp->isp_devparam[tgt].dev_flags &= ~DPARM_QFRZ;
4194 1.58 mjacob
4195 1.31 mjacob mbs.param[2] = sdp->isp_devparam[tgt].dev_flags;
4196 1.58 mjacob
4197 1.36 mjacob /*
4198 1.58 mjacob * Insist that PARITY must be enabled
4199 1.58 mjacob * if SYNC or WIDE is enabled.
4200 1.36 mjacob */
4201 1.58 mjacob if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) {
4202 1.36 mjacob mbs.param[2] |= DPARM_PARITY;
4203 1.36 mjacob }
4204 1.58 mjacob
4205 1.58 mjacob if ((mbs.param[2] & DPARM_SYNC) == 0) {
4206 1.58 mjacob mbs.param[3] = 0;
4207 1.58 mjacob } else {
4208 1.58 mjacob mbs.param[3] =
4209 1.58 mjacob (sdp->isp_devparam[tgt].sync_offset << 8) |
4210 1.58 mjacob (sdp->isp_devparam[tgt].sync_period);
4211 1.58 mjacob }
4212 1.34 mjacob /*
4213 1.34 mjacob * A command completion later that has
4214 1.60 mjacob * RQSTF_NEGOTIATION set canl cause
4215 1.60 mjacob * the dev_refresh/announce cycle also.
4216 1.60 mjacob &
4217 1.34 mjacob *
4218 1.34 mjacob * Note: It is really important to update our current
4219 1.34 mjacob * flags with at least the state of TAG capabilities-
4220 1.34 mjacob * otherwise we might try and send a tagged command
4221 1.34 mjacob * when we have it all turned off. So change it here
4222 1.34 mjacob * to say that current already matches goal.
4223 1.34 mjacob */
4224 1.34 mjacob sdp->isp_devparam[tgt].cur_dflags &= ~DPARM_TQING;
4225 1.34 mjacob sdp->isp_devparam[tgt].cur_dflags |=
4226 1.34 mjacob (sdp->isp_devparam[tgt].dev_flags & DPARM_TQING);
4227 1.60 mjacob isp_prt(isp, ISP_LOGDEBUG2,
4228 1.57 mjacob "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
4229 1.57 mjacob bus, tgt, mbs.param[2], mbs.param[3] >> 8,
4230 1.57 mjacob mbs.param[3] & 0xff);
4231 1.60 mjacob sdp->isp_devparam[tgt].dev_update = 0;
4232 1.60 mjacob sdp->isp_devparam[tgt].dev_refresh = 1;
4233 1.31 mjacob get = 0;
4234 1.31 mjacob } else {
4235 1.25 mjacob continue;
4236 1.25 mjacob }
4237 1.36 mjacob mbs.param[1] = (bus << 15) | (tgt << 8) ;
4238 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
4239 1.31 mjacob if (get == 0) {
4240 1.36 mjacob isp->isp_sendmarker |= (1 << bus);
4241 1.31 mjacob continue;
4242 1.31 mjacob }
4243 1.31 mjacob flags = mbs.param[2];
4244 1.31 mjacob period = mbs.param[3] & 0xff;
4245 1.31 mjacob offset = mbs.param[3] >> 8;
4246 1.31 mjacob sdp->isp_devparam[tgt].cur_dflags = flags;
4247 1.34 mjacob sdp->isp_devparam[tgt].cur_period = period;
4248 1.34 mjacob sdp->isp_devparam[tgt].cur_offset = offset;
4249 1.36 mjacob get = (bus << 16) | tgt;
4250 1.36 mjacob (void) isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &get);
4251 1.10 mjacob }
4252 1.60 mjacob
4253 1.60 mjacob for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
4254 1.60 mjacob if (sdp->isp_devparam[tgt].dev_update ||
4255 1.60 mjacob sdp->isp_devparam[tgt].dev_refresh) {
4256 1.60 mjacob isp->isp_update |= (1 << bus);
4257 1.60 mjacob break;
4258 1.60 mjacob }
4259 1.60 mjacob }
4260 1.25 mjacob }
4261 1.10 mjacob
4262 1.25 mjacob static void
4263 1.36 mjacob isp_setdfltparm(isp, channel)
4264 1.25 mjacob struct ispsoftc *isp;
4265 1.36 mjacob int channel;
4266 1.25 mjacob {
4267 1.34 mjacob int tgt;
4268 1.25 mjacob mbreg_t mbs;
4269 1.45 mjacob sdparam *sdp;
4270 1.36 mjacob
4271 1.36 mjacob if (IS_FC(isp)) {
4272 1.36 mjacob fcparam *fcp = (fcparam *) isp->isp_param;
4273 1.36 mjacob fcp += channel;
4274 1.36 mjacob if (fcp->isp_gotdparms) {
4275 1.36 mjacob return;
4276 1.36 mjacob }
4277 1.36 mjacob fcp->isp_gotdparms = 1;
4278 1.37 mjacob fcp->isp_maxfrmlen = ICB_DFLT_FRMLEN;
4279 1.37 mjacob fcp->isp_maxalloc = ICB_DFLT_ALLOC;
4280 1.61 mjacob fcp->isp_execthrottle = ISP_EXEC_THROTTLE;
4281 1.37 mjacob fcp->isp_retry_delay = ICB_DFLT_RDELAY;
4282 1.37 mjacob fcp->isp_retry_count = ICB_DFLT_RCOUNT;
4283 1.37 mjacob /* Platform specific.... */
4284 1.37 mjacob fcp->isp_loopid = DEFAULT_LOOPID(isp);
4285 1.57 mjacob fcp->isp_nodewwn = DEFAULT_NODEWWN(isp);
4286 1.57 mjacob fcp->isp_portwwn = DEFAULT_PORTWWN(isp);
4287 1.58 mjacob fcp->isp_fwoptions = 0;
4288 1.58 mjacob fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
4289 1.58 mjacob fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
4290 1.58 mjacob fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
4291 1.58 mjacob #ifndef ISP_NO_FASTPOST_FC
4292 1.58 mjacob fcp->isp_fwoptions |= ICBOPT_FAST_POST;
4293 1.58 mjacob #endif
4294 1.58 mjacob if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
4295 1.58 mjacob fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
4296 1.58 mjacob
4297 1.58 mjacob /*
4298 1.58 mjacob * Make sure this is turned off now until we get
4299 1.58 mjacob * extended options from NVRAM
4300 1.58 mjacob */
4301 1.58 mjacob fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
4302 1.57 mjacob
4303 1.37 mjacob /*
4304 1.37 mjacob * Now try and read NVRAM
4305 1.37 mjacob */
4306 1.43 mjacob if ((isp->isp_confopts & (ISP_CFG_NONVRAM|ISP_CFG_OWNWWN)) ||
4307 1.43 mjacob (isp_read_nvram(isp))) {
4308 1.57 mjacob isp_prt(isp, ISP_LOGINFO,
4309 1.57 mjacob "Node WWN 0x%08x%08x, Port WWN 0x%08x%08x",
4310 1.57 mjacob (u_int32_t) (fcp->isp_nodewwn >> 32),
4311 1.52 he (u_int32_t) (fcp->isp_nodewwn & 0xffffffff),
4312 1.52 he (u_int32_t) (fcp->isp_portwwn >> 32),
4313 1.52 he (u_int32_t) (fcp->isp_portwwn & 0xffffffff));
4314 1.36 mjacob }
4315 1.36 mjacob return;
4316 1.36 mjacob }
4317 1.36 mjacob
4318 1.45 mjacob sdp = (sdparam *) isp->isp_param;
4319 1.45 mjacob sdp += channel;
4320 1.10 mjacob
4321 1.10 mjacob /*
4322 1.25 mjacob * Been there, done that, got the T-shirt...
4323 1.10 mjacob */
4324 1.36 mjacob if (sdp->isp_gotdparms) {
4325 1.25 mjacob return;
4326 1.25 mjacob }
4327 1.36 mjacob sdp->isp_gotdparms = 1;
4328 1.25 mjacob
4329 1.34 mjacob /*
4330 1.34 mjacob * If we've not been told to avoid reading NVRAM, try and read it.
4331 1.34 mjacob * If we're successful reading it, we can return since NVRAM will
4332 1.34 mjacob * tell us the right thing to do. Otherwise, establish some reasonable
4333 1.34 mjacob * defaults.
4334 1.34 mjacob */
4335 1.34 mjacob if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
4336 1.34 mjacob if (isp_read_nvram(isp) == 0) {
4337 1.34 mjacob return;
4338 1.34 mjacob }
4339 1.25 mjacob }
4340 1.10 mjacob
4341 1.36 mjacob /*
4342 1.36 mjacob * Now try and see whether we have specific values for them.
4343 1.36 mjacob */
4344 1.45 mjacob if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
4345 1.45 mjacob mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
4346 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
4347 1.45 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4348 1.45 mjacob sdp->isp_req_ack_active_neg = 1;
4349 1.45 mjacob sdp->isp_data_line_active_neg = 1;
4350 1.45 mjacob } else {
4351 1.45 mjacob sdp->isp_req_ack_active_neg =
4352 1.45 mjacob (mbs.param[1+channel] >> 4) & 0x1;
4353 1.45 mjacob sdp->isp_data_line_active_neg =
4354 1.45 mjacob (mbs.param[1+channel] >> 5) & 0x1;
4355 1.36 mjacob }
4356 1.10 mjacob } else {
4357 1.45 mjacob sdp->isp_req_ack_active_neg = 1;
4358 1.45 mjacob sdp->isp_data_line_active_neg = 1;
4359 1.10 mjacob }
4360 1.32 mjacob
4361 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG1,
4362 1.57 mjacob "defaulting bus %d REQ/ACK Active Negation is %d",
4363 1.57 mjacob channel, sdp->isp_req_ack_active_neg);
4364 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG1,
4365 1.57 mjacob "defaulting bus %d DATA Active Negation is %d",
4366 1.57 mjacob channel, sdp->isp_data_line_active_neg);
4367 1.45 mjacob
4368 1.34 mjacob /*
4369 1.34 mjacob * The trick here is to establish a default for the default (honk!)
4370 1.34 mjacob * state (dev_flags). Then try and get the current status from
4371 1.34 mjacob * the card to fill in the current state. We don't, in fact, set
4372 1.34 mjacob * the default to the SAFE default state- that's not the goal state.
4373 1.34 mjacob */
4374 1.34 mjacob for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
4375 1.34 mjacob sdp->isp_devparam[tgt].cur_offset = 0;
4376 1.34 mjacob sdp->isp_devparam[tgt].cur_period = 0;
4377 1.34 mjacob sdp->isp_devparam[tgt].dev_flags = DPARM_DEFAULT;
4378 1.34 mjacob sdp->isp_devparam[tgt].cur_dflags = 0;
4379 1.48 mjacob /*
4380 1.48 mjacob * We default to Wide/Fast for versions less than a 1040
4381 1.48 mjacob * (unless it's SBus).
4382 1.48 mjacob */
4383 1.48 mjacob if ((isp->isp_bustype == ISP_BT_SBUS &&
4384 1.48 mjacob isp->isp_type < ISP_HA_SCSI_1020A) ||
4385 1.48 mjacob (isp->isp_bustype == ISP_BT_PCI &&
4386 1.48 mjacob isp->isp_type < ISP_HA_SCSI_1040) ||
4387 1.52 he (isp->isp_clock && isp->isp_clock < 60) ||
4388 1.52 he (sdp->isp_ultramode == 0)) {
4389 1.34 mjacob sdp->isp_devparam[tgt].sync_offset =
4390 1.32 mjacob ISP_10M_SYNCPARMS >> 8;
4391 1.34 mjacob sdp->isp_devparam[tgt].sync_period =
4392 1.32 mjacob ISP_10M_SYNCPARMS & 0xff;
4393 1.58 mjacob } else if (IS_ULTRA3(isp)) {
4394 1.58 mjacob sdp->isp_devparam[tgt].sync_offset =
4395 1.58 mjacob ISP_80M_SYNCPARMS >> 8;
4396 1.58 mjacob sdp->isp_devparam[tgt].sync_period =
4397 1.58 mjacob ISP_80M_SYNCPARMS & 0xff;
4398 1.44 mjacob } else if (IS_ULTRA2(isp)) {
4399 1.34 mjacob sdp->isp_devparam[tgt].sync_offset =
4400 1.34 mjacob ISP_40M_SYNCPARMS >> 8;
4401 1.34 mjacob sdp->isp_devparam[tgt].sync_period =
4402 1.34 mjacob ISP_40M_SYNCPARMS & 0xff;
4403 1.58 mjacob } else if (IS_1240(isp)) {
4404 1.34 mjacob sdp->isp_devparam[tgt].sync_offset =
4405 1.32 mjacob ISP_20M_SYNCPARMS >> 8;
4406 1.34 mjacob sdp->isp_devparam[tgt].sync_period =
4407 1.32 mjacob ISP_20M_SYNCPARMS & 0xff;
4408 1.58 mjacob } else {
4409 1.58 mjacob sdp->isp_devparam[tgt].sync_offset =
4410 1.58 mjacob ISP_20M_SYNCPARMS_1040 >> 8;
4411 1.58 mjacob sdp->isp_devparam[tgt].sync_period =
4412 1.58 mjacob ISP_20M_SYNCPARMS_1040 & 0xff;
4413 1.32 mjacob }
4414 1.32 mjacob
4415 1.32 mjacob /*
4416 1.32 mjacob * Don't get current target parameters if we've been
4417 1.32 mjacob * told not to use NVRAM- it's really the same thing.
4418 1.32 mjacob */
4419 1.45 mjacob if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
4420 1.25 mjacob
4421 1.45 mjacob mbs.param[0] = MBOX_GET_TARGET_PARAMS;
4422 1.45 mjacob mbs.param[1] = tgt << 8;
4423 1.57 mjacob isp_mboxcmd(isp, &mbs, MBLOGALL);
4424 1.45 mjacob if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4425 1.45 mjacob continue;
4426 1.45 mjacob }
4427 1.45 mjacob sdp->isp_devparam[tgt].cur_dflags = mbs.param[2];
4428 1.45 mjacob sdp->isp_devparam[tgt].dev_flags = mbs.param[2];
4429 1.45 mjacob sdp->isp_devparam[tgt].cur_period = mbs.param[3] & 0xff;
4430 1.45 mjacob sdp->isp_devparam[tgt].cur_offset = mbs.param[3] >> 8;
4431 1.34 mjacob
4432 1.45 mjacob /*
4433 1.45 mjacob * The maximum period we can really see
4434 1.45 mjacob * here is 100 (decimal), or 400 ns.
4435 1.45 mjacob * For some unknown reason we sometimes
4436 1.45 mjacob * get back wildass numbers from the
4437 1.45 mjacob * boot device's parameters (alpha only).
4438 1.45 mjacob */
4439 1.45 mjacob if ((mbs.param[3] & 0xff) <= 0x64) {
4440 1.45 mjacob sdp->isp_devparam[tgt].sync_period =
4441 1.45 mjacob mbs.param[3] & 0xff;
4442 1.45 mjacob sdp->isp_devparam[tgt].sync_offset =
4443 1.45 mjacob mbs.param[3] >> 8;
4444 1.45 mjacob }
4445 1.25 mjacob
4446 1.45 mjacob /*
4447 1.45 mjacob * It is not safe to run Ultra Mode with a clock < 60.
4448 1.45 mjacob */
4449 1.45 mjacob if (((isp->isp_clock && isp->isp_clock < 60) ||
4450 1.45 mjacob (isp->isp_type < ISP_HA_SCSI_1020A)) &&
4451 1.45 mjacob (sdp->isp_devparam[tgt].sync_period <=
4452 1.45 mjacob (ISP_20M_SYNCPARMS & 0xff))) {
4453 1.45 mjacob sdp->isp_devparam[tgt].sync_offset =
4454 1.45 mjacob ISP_10M_SYNCPARMS >> 8;
4455 1.45 mjacob sdp->isp_devparam[tgt].sync_period =
4456 1.45 mjacob ISP_10M_SYNCPARMS & 0xff;
4457 1.45 mjacob }
4458 1.10 mjacob }
4459 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG1,
4460 1.60 mjacob "Initial bus %d tgt %d flags %x offset %x period %x",
4461 1.57 mjacob channel, tgt, sdp->isp_devparam[tgt].dev_flags,
4462 1.48 mjacob sdp->isp_devparam[tgt].sync_offset,
4463 1.57 mjacob sdp->isp_devparam[tgt].sync_period);
4464 1.10 mjacob }
4465 1.10 mjacob
4466 1.10 mjacob /*
4467 1.36 mjacob * Establish default some more default parameters.
4468 1.10 mjacob */
4469 1.10 mjacob sdp->isp_cmd_dma_burst_enable = 1;
4470 1.10 mjacob sdp->isp_data_dma_burst_enabl = 1;
4471 1.25 mjacob sdp->isp_fifo_threshold = 0;
4472 1.57 mjacob sdp->isp_initiator_id = DEFAULT_IID(isp);
4473 1.25 mjacob if (isp->isp_type >= ISP_HA_SCSI_1040) {
4474 1.25 mjacob sdp->isp_async_data_setup = 9;
4475 1.25 mjacob } else {
4476 1.25 mjacob sdp->isp_async_data_setup = 6;
4477 1.25 mjacob }
4478 1.10 mjacob sdp->isp_selection_timeout = 250;
4479 1.57 mjacob sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
4480 1.10 mjacob sdp->isp_tag_aging = 8;
4481 1.10 mjacob sdp->isp_bus_reset_delay = 3;
4482 1.36 mjacob sdp->isp_retry_count = 2;
4483 1.36 mjacob sdp->isp_retry_delay = 2;
4484 1.10 mjacob
4485 1.34 mjacob for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
4486 1.61 mjacob sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE;
4487 1.34 mjacob sdp->isp_devparam[tgt].dev_enable = 1;
4488 1.10 mjacob }
4489 1.10 mjacob }
4490 1.10 mjacob
4491 1.34 mjacob /*
4492 1.24 mjacob * Re-initialize the ISP and complete all orphaned commands
4493 1.38 mjacob * with a 'botched' notice. The reset/init routines should
4494 1.38 mjacob * not disturb an already active list of commands.
4495 1.24 mjacob *
4496 1.24 mjacob * Locks held prior to coming here.
4497 1.24 mjacob */
4498 1.24 mjacob
4499 1.24 mjacob void
4500 1.57 mjacob isp_reinit(isp)
4501 1.25 mjacob struct ispsoftc *isp;
4502 1.10 mjacob {
4503 1.57 mjacob XS_T *xs;
4504 1.38 mjacob u_int32_t handle;
4505 1.10 mjacob
4506 1.10 mjacob isp_reset(isp);
4507 1.24 mjacob if (isp->isp_state == ISP_RESETSTATE) {
4508 1.24 mjacob isp_init(isp);
4509 1.24 mjacob if (isp->isp_state == ISP_INITSTATE) {
4510 1.24 mjacob isp->isp_state = ISP_RUNSTATE;
4511 1.24 mjacob }
4512 1.24 mjacob }
4513 1.24 mjacob if (isp->isp_state != ISP_RUNSTATE) {
4514 1.57 mjacob isp_prt(isp, ISP_LOGERR, "isp_reinit cannot restart ISP");
4515 1.24 mjacob }
4516 1.38 mjacob isp->isp_nactive = 0;
4517 1.10 mjacob
4518 1.57 mjacob for (handle = 1; (int) handle <= isp->isp_maxcmds; handle++) {
4519 1.38 mjacob xs = isp_find_xs(isp, handle);
4520 1.38 mjacob if (xs == NULL) {
4521 1.10 mjacob continue;
4522 1.27 mjacob }
4523 1.38 mjacob isp_destroy_handle(isp, handle);
4524 1.38 mjacob if (XS_XFRLEN(xs)) {
4525 1.38 mjacob ISP_DMAFREE(isp, xs, handle);
4526 1.38 mjacob XS_RESID(xs) = XS_XFRLEN(xs);
4527 1.38 mjacob } else {
4528 1.38 mjacob XS_RESID(xs) = 0;
4529 1.38 mjacob }
4530 1.27 mjacob XS_SETERR(xs, HBA_BUSRESET);
4531 1.57 mjacob isp_done(xs);
4532 1.10 mjacob }
4533 1.15 mjacob }
4534 1.15 mjacob
4535 1.28 mjacob /*
4536 1.25 mjacob * NVRAM Routines
4537 1.25 mjacob */
4538 1.25 mjacob static int
4539 1.25 mjacob isp_read_nvram(isp)
4540 1.25 mjacob struct ispsoftc *isp;
4541 1.25 mjacob {
4542 1.25 mjacob int i, amt;
4543 1.25 mjacob u_int8_t csum, minversion;
4544 1.25 mjacob union {
4545 1.25 mjacob u_int8_t _x[ISP2100_NVRAM_SIZE];
4546 1.25 mjacob u_int16_t _s[ISP2100_NVRAM_SIZE>>1];
4547 1.25 mjacob } _n;
4548 1.25 mjacob #define nvram_data _n._x
4549 1.25 mjacob #define nvram_words _n._s
4550 1.25 mjacob
4551 1.33 mjacob if (IS_FC(isp)) {
4552 1.25 mjacob amt = ISP2100_NVRAM_SIZE;
4553 1.25 mjacob minversion = 1;
4554 1.44 mjacob } else if (IS_ULTRA2(isp)) {
4555 1.36 mjacob amt = ISP1080_NVRAM_SIZE;
4556 1.36 mjacob minversion = 0;
4557 1.25 mjacob } else {
4558 1.25 mjacob amt = ISP_NVRAM_SIZE;
4559 1.25 mjacob minversion = 2;
4560 1.25 mjacob }
4561 1.25 mjacob
4562 1.25 mjacob /*
4563 1.25 mjacob * Just read the first two words first to see if we have a valid
4564 1.25 mjacob * NVRAM to continue reading the rest with.
4565 1.25 mjacob */
4566 1.25 mjacob for (i = 0; i < 2; i++) {
4567 1.25 mjacob isp_rdnvram_word(isp, i, &nvram_words[i]);
4568 1.25 mjacob }
4569 1.25 mjacob if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
4570 1.25 mjacob nvram_data[2] != 'P') {
4571 1.25 mjacob if (isp->isp_bustype != ISP_BT_SBUS) {
4572 1.57 mjacob isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
4573 1.57 mjacob isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x",
4574 1.57 mjacob nvram_data[0], nvram_data[1], nvram_data[2]);
4575 1.25 mjacob }
4576 1.25 mjacob return (-1);
4577 1.25 mjacob }
4578 1.25 mjacob for (i = 2; i < amt>>1; i++) {
4579 1.25 mjacob isp_rdnvram_word(isp, i, &nvram_words[i]);
4580 1.25 mjacob }
4581 1.25 mjacob for (csum = 0, i = 0; i < amt; i++) {
4582 1.25 mjacob csum += nvram_data[i];
4583 1.25 mjacob }
4584 1.25 mjacob if (csum != 0) {
4585 1.57 mjacob isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
4586 1.25 mjacob return (-1);
4587 1.25 mjacob }
4588 1.25 mjacob if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
4589 1.57 mjacob isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
4590 1.25 mjacob ISP_NVRAM_VERSION(nvram_data));
4591 1.25 mjacob return (-1);
4592 1.25 mjacob }
4593 1.25 mjacob
4594 1.49 mjacob if (IS_ULTRA3(isp)) {
4595 1.49 mjacob isp_parse_nvram_12160(isp, 0, nvram_data);
4596 1.49 mjacob isp_parse_nvram_12160(isp, 1, nvram_data);
4597 1.49 mjacob } else if (IS_1080(isp)) {
4598 1.49 mjacob isp_parse_nvram_1080(isp, 0, nvram_data);
4599 1.49 mjacob } else if (IS_1280(isp) || IS_1240(isp)) {
4600 1.49 mjacob isp_parse_nvram_1080(isp, 0, nvram_data);
4601 1.49 mjacob isp_parse_nvram_1080(isp, 1, nvram_data);
4602 1.36 mjacob } else if (IS_SCSI(isp)) {
4603 1.49 mjacob isp_parse_nvram_1020(isp, nvram_data);
4604 1.25 mjacob } else {
4605 1.49 mjacob isp_parse_nvram_2100(isp, nvram_data);
4606 1.25 mjacob }
4607 1.25 mjacob return (0);
4608 1.49 mjacob #undef nvram_data
4609 1.49 mjacob #undef nvram_words
4610 1.25 mjacob }
4611 1.25 mjacob
4612 1.25 mjacob static void
4613 1.25 mjacob isp_rdnvram_word(isp, wo, rp)
4614 1.25 mjacob struct ispsoftc *isp;
4615 1.25 mjacob int wo;
4616 1.25 mjacob u_int16_t *rp;
4617 1.25 mjacob {
4618 1.25 mjacob int i, cbits;
4619 1.25 mjacob u_int16_t bit, rqst;
4620 1.25 mjacob
4621 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
4622 1.57 mjacob USEC_DELAY(2);
4623 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
4624 1.57 mjacob USEC_DELAY(2);
4625 1.25 mjacob
4626 1.36 mjacob if (IS_FC(isp)) {
4627 1.25 mjacob wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
4628 1.36 mjacob rqst = (ISP_NVRAM_READ << 8) | wo;
4629 1.36 mjacob cbits = 10;
4630 1.44 mjacob } else if (IS_ULTRA2(isp)) {
4631 1.36 mjacob wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1);
4632 1.25 mjacob rqst = (ISP_NVRAM_READ << 8) | wo;
4633 1.25 mjacob cbits = 10;
4634 1.25 mjacob } else {
4635 1.25 mjacob wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
4636 1.25 mjacob rqst = (ISP_NVRAM_READ << 6) | wo;
4637 1.25 mjacob cbits = 8;
4638 1.25 mjacob }
4639 1.25 mjacob
4640 1.25 mjacob /*
4641 1.25 mjacob * Clock the word select request out...
4642 1.25 mjacob */
4643 1.25 mjacob for (i = cbits; i >= 0; i--) {
4644 1.25 mjacob if ((rqst >> i) & 1) {
4645 1.25 mjacob bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
4646 1.25 mjacob } else {
4647 1.25 mjacob bit = BIU_NVRAM_SELECT;
4648 1.25 mjacob }
4649 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, bit);
4650 1.57 mjacob USEC_DELAY(2);
4651 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
4652 1.57 mjacob USEC_DELAY(2);
4653 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, bit);
4654 1.57 mjacob USEC_DELAY(2);
4655 1.25 mjacob }
4656 1.25 mjacob /*
4657 1.25 mjacob * Now read the result back in (bits come back in MSB format).
4658 1.25 mjacob */
4659 1.25 mjacob *rp = 0;
4660 1.25 mjacob for (i = 0; i < 16; i++) {
4661 1.25 mjacob u_int16_t rv;
4662 1.25 mjacob *rp <<= 1;
4663 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
4664 1.57 mjacob USEC_DELAY(2);
4665 1.25 mjacob rv = ISP_READ(isp, BIU_NVRAM);
4666 1.25 mjacob if (rv & BIU_NVRAM_DATAIN) {
4667 1.25 mjacob *rp |= 1;
4668 1.25 mjacob }
4669 1.57 mjacob USEC_DELAY(2);
4670 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
4671 1.57 mjacob USEC_DELAY(2);
4672 1.25 mjacob }
4673 1.25 mjacob ISP_WRITE(isp, BIU_NVRAM, 0);
4674 1.57 mjacob USEC_DELAY(2);
4675 1.57 mjacob ISP_SWIZZLE_NVRAM_WORD(isp, rp);
4676 1.49 mjacob }
4677 1.49 mjacob
4678 1.49 mjacob static void
4679 1.49 mjacob isp_parse_nvram_1020(isp, nvram_data)
4680 1.49 mjacob struct ispsoftc *isp;
4681 1.49 mjacob u_int8_t *nvram_data;
4682 1.49 mjacob {
4683 1.49 mjacob int i;
4684 1.49 mjacob sdparam *sdp = (sdparam *) isp->isp_param;
4685 1.49 mjacob
4686 1.49 mjacob sdp->isp_fifo_threshold =
4687 1.49 mjacob ISP_NVRAM_FIFO_THRESHOLD(nvram_data) |
4688 1.49 mjacob (ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2);
4689 1.49 mjacob
4690 1.49 mjacob sdp->isp_initiator_id =
4691 1.49 mjacob ISP_NVRAM_INITIATOR_ID(nvram_data);
4692 1.49 mjacob
4693 1.49 mjacob sdp->isp_bus_reset_delay =
4694 1.49 mjacob ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
4695 1.49 mjacob
4696 1.49 mjacob sdp->isp_retry_count =
4697 1.49 mjacob ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
4698 1.49 mjacob
4699 1.49 mjacob sdp->isp_retry_delay =
4700 1.49 mjacob ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
4701 1.49 mjacob
4702 1.49 mjacob sdp->isp_async_data_setup =
4703 1.49 mjacob ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
4704 1.49 mjacob
4705 1.49 mjacob if (isp->isp_type >= ISP_HA_SCSI_1040) {
4706 1.49 mjacob if (sdp->isp_async_data_setup < 9) {
4707 1.49 mjacob sdp->isp_async_data_setup = 9;
4708 1.49 mjacob }
4709 1.49 mjacob } else {
4710 1.49 mjacob if (sdp->isp_async_data_setup != 6) {
4711 1.49 mjacob sdp->isp_async_data_setup = 6;
4712 1.49 mjacob }
4713 1.49 mjacob }
4714 1.49 mjacob
4715 1.49 mjacob sdp->isp_req_ack_active_neg =
4716 1.49 mjacob ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
4717 1.49 mjacob
4718 1.49 mjacob sdp->isp_data_line_active_neg =
4719 1.49 mjacob ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
4720 1.49 mjacob
4721 1.49 mjacob sdp->isp_data_dma_burst_enabl =
4722 1.49 mjacob ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
4723 1.49 mjacob
4724 1.49 mjacob sdp->isp_cmd_dma_burst_enable =
4725 1.49 mjacob ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
4726 1.49 mjacob
4727 1.49 mjacob sdp->isp_tag_aging =
4728 1.49 mjacob ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
4729 1.49 mjacob
4730 1.49 mjacob sdp->isp_selection_timeout =
4731 1.49 mjacob ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
4732 1.49 mjacob
4733 1.49 mjacob sdp->isp_max_queue_depth =
4734 1.49 mjacob ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
4735 1.49 mjacob
4736 1.58 mjacob sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
4737 1.49 mjacob for (i = 0; i < MAX_TARGETS; i++) {
4738 1.49 mjacob sdp->isp_devparam[i].dev_enable =
4739 1.49 mjacob ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i);
4740 1.49 mjacob sdp->isp_devparam[i].exc_throttle =
4741 1.49 mjacob ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, i);
4742 1.49 mjacob sdp->isp_devparam[i].sync_offset =
4743 1.49 mjacob ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, i);
4744 1.49 mjacob sdp->isp_devparam[i].sync_period =
4745 1.49 mjacob ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, i);
4746 1.49 mjacob
4747 1.49 mjacob if (isp->isp_type < ISP_HA_SCSI_1040) {
4748 1.49 mjacob /*
4749 1.49 mjacob * If we're not ultra, we can't possibly
4750 1.49 mjacob * be a shorter period than this.
4751 1.49 mjacob */
4752 1.49 mjacob if (sdp->isp_devparam[i].sync_period < 0x19) {
4753 1.57 mjacob sdp->isp_devparam[i].sync_period = 0x19;
4754 1.49 mjacob }
4755 1.49 mjacob if (sdp->isp_devparam[i].sync_offset > 0xc) {
4756 1.57 mjacob sdp->isp_devparam[i].sync_offset = 0x0c;
4757 1.49 mjacob }
4758 1.49 mjacob } else {
4759 1.49 mjacob if (sdp->isp_devparam[i].sync_offset > 0x8) {
4760 1.49 mjacob sdp->isp_devparam[i].sync_offset = 0x8;
4761 1.49 mjacob }
4762 1.49 mjacob }
4763 1.49 mjacob sdp->isp_devparam[i].dev_flags = 0;
4764 1.49 mjacob if (ISP_NVRAM_TGT_RENEG(nvram_data, i))
4765 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_RENEG;
4766 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_ARQ;
4767 1.49 mjacob if (ISP_NVRAM_TGT_TQING(nvram_data, i))
4768 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_TQING;
4769 1.49 mjacob if (ISP_NVRAM_TGT_SYNC(nvram_data, i))
4770 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_SYNC;
4771 1.49 mjacob if (ISP_NVRAM_TGT_WIDE(nvram_data, i))
4772 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_WIDE;
4773 1.49 mjacob if (ISP_NVRAM_TGT_PARITY(nvram_data, i))
4774 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_PARITY;
4775 1.49 mjacob if (ISP_NVRAM_TGT_DISC(nvram_data, i))
4776 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_DISC;
4777 1.49 mjacob sdp->isp_devparam[i].cur_dflags = 0; /* we don't know */
4778 1.49 mjacob }
4779 1.49 mjacob }
4780 1.49 mjacob
4781 1.49 mjacob static void
4782 1.49 mjacob isp_parse_nvram_1080(isp, bus, nvram_data)
4783 1.49 mjacob struct ispsoftc *isp;
4784 1.49 mjacob int bus;
4785 1.49 mjacob u_int8_t *nvram_data;
4786 1.49 mjacob {
4787 1.49 mjacob int i;
4788 1.49 mjacob sdparam *sdp = (sdparam *) isp->isp_param;
4789 1.49 mjacob sdp += bus;
4790 1.49 mjacob
4791 1.49 mjacob sdp->isp_fifo_threshold =
4792 1.49 mjacob ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data);
4793 1.49 mjacob
4794 1.49 mjacob sdp->isp_initiator_id =
4795 1.49 mjacob ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus);
4796 1.49 mjacob
4797 1.49 mjacob sdp->isp_bus_reset_delay =
4798 1.49 mjacob ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
4799 1.49 mjacob
4800 1.49 mjacob sdp->isp_retry_count =
4801 1.49 mjacob ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
4802 1.49 mjacob
4803 1.49 mjacob sdp->isp_retry_delay =
4804 1.49 mjacob ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
4805 1.49 mjacob
4806 1.49 mjacob sdp->isp_async_data_setup =
4807 1.49 mjacob ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data,
4808 1.49 mjacob bus);
4809 1.49 mjacob
4810 1.49 mjacob sdp->isp_req_ack_active_neg =
4811 1.49 mjacob ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data,
4812 1.49 mjacob bus);
4813 1.49 mjacob
4814 1.49 mjacob sdp->isp_data_line_active_neg =
4815 1.49 mjacob ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data,
4816 1.49 mjacob bus);
4817 1.49 mjacob
4818 1.49 mjacob sdp->isp_data_dma_burst_enabl =
4819 1.49 mjacob ISP1080_NVRAM_BURST_ENABLE(nvram_data);
4820 1.49 mjacob
4821 1.49 mjacob sdp->isp_cmd_dma_burst_enable =
4822 1.49 mjacob ISP1080_NVRAM_BURST_ENABLE(nvram_data);
4823 1.49 mjacob
4824 1.49 mjacob sdp->isp_selection_timeout =
4825 1.49 mjacob ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
4826 1.49 mjacob
4827 1.49 mjacob sdp->isp_max_queue_depth =
4828 1.49 mjacob ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
4829 1.49 mjacob
4830 1.49 mjacob for (i = 0; i < MAX_TARGETS; i++) {
4831 1.49 mjacob sdp->isp_devparam[i].dev_enable =
4832 1.49 mjacob ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i, bus);
4833 1.49 mjacob sdp->isp_devparam[i].exc_throttle =
4834 1.49 mjacob ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, i, bus);
4835 1.49 mjacob sdp->isp_devparam[i].sync_offset =
4836 1.49 mjacob ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, i, bus);
4837 1.49 mjacob sdp->isp_devparam[i].sync_period =
4838 1.49 mjacob ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, i, bus);
4839 1.49 mjacob sdp->isp_devparam[i].dev_flags = 0;
4840 1.49 mjacob if (ISP1080_NVRAM_TGT_RENEG(nvram_data, i, bus))
4841 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_RENEG;
4842 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_ARQ;
4843 1.49 mjacob if (ISP1080_NVRAM_TGT_TQING(nvram_data, i, bus))
4844 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_TQING;
4845 1.49 mjacob if (ISP1080_NVRAM_TGT_SYNC(nvram_data, i, bus))
4846 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_SYNC;
4847 1.49 mjacob if (ISP1080_NVRAM_TGT_WIDE(nvram_data, i, bus))
4848 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_WIDE;
4849 1.49 mjacob if (ISP1080_NVRAM_TGT_PARITY(nvram_data, i, bus))
4850 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_PARITY;
4851 1.49 mjacob if (ISP1080_NVRAM_TGT_DISC(nvram_data, i, bus))
4852 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_DISC;
4853 1.49 mjacob sdp->isp_devparam[i].cur_dflags = 0;
4854 1.49 mjacob }
4855 1.49 mjacob }
4856 1.49 mjacob
4857 1.49 mjacob static void
4858 1.49 mjacob isp_parse_nvram_12160(isp, bus, nvram_data)
4859 1.49 mjacob struct ispsoftc *isp;
4860 1.49 mjacob int bus;
4861 1.49 mjacob u_int8_t *nvram_data;
4862 1.49 mjacob {
4863 1.49 mjacob sdparam *sdp = (sdparam *) isp->isp_param;
4864 1.49 mjacob int i;
4865 1.49 mjacob
4866 1.49 mjacob sdp += bus;
4867 1.49 mjacob
4868 1.49 mjacob sdp->isp_fifo_threshold =
4869 1.49 mjacob ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data);
4870 1.49 mjacob
4871 1.49 mjacob sdp->isp_initiator_id =
4872 1.49 mjacob ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus);
4873 1.49 mjacob
4874 1.49 mjacob sdp->isp_bus_reset_delay =
4875 1.49 mjacob ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
4876 1.49 mjacob
4877 1.49 mjacob sdp->isp_retry_count =
4878 1.49 mjacob ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
4879 1.49 mjacob
4880 1.49 mjacob sdp->isp_retry_delay =
4881 1.49 mjacob ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
4882 1.49 mjacob
4883 1.49 mjacob sdp->isp_async_data_setup =
4884 1.49 mjacob ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data,
4885 1.49 mjacob bus);
4886 1.49 mjacob
4887 1.49 mjacob sdp->isp_req_ack_active_neg =
4888 1.49 mjacob ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data,
4889 1.49 mjacob bus);
4890 1.49 mjacob
4891 1.49 mjacob sdp->isp_data_line_active_neg =
4892 1.49 mjacob ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data,
4893 1.49 mjacob bus);
4894 1.49 mjacob
4895 1.49 mjacob sdp->isp_data_dma_burst_enabl =
4896 1.49 mjacob ISP12160_NVRAM_BURST_ENABLE(nvram_data);
4897 1.49 mjacob
4898 1.49 mjacob sdp->isp_cmd_dma_burst_enable =
4899 1.49 mjacob ISP12160_NVRAM_BURST_ENABLE(nvram_data);
4900 1.49 mjacob
4901 1.49 mjacob sdp->isp_selection_timeout =
4902 1.49 mjacob ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
4903 1.49 mjacob
4904 1.49 mjacob sdp->isp_max_queue_depth =
4905 1.49 mjacob ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
4906 1.49 mjacob
4907 1.49 mjacob for (i = 0; i < MAX_TARGETS; i++) {
4908 1.49 mjacob sdp->isp_devparam[i].dev_enable =
4909 1.49 mjacob ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i, bus);
4910 1.49 mjacob sdp->isp_devparam[i].exc_throttle =
4911 1.49 mjacob ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, i, bus);
4912 1.49 mjacob sdp->isp_devparam[i].sync_offset =
4913 1.49 mjacob ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, i, bus);
4914 1.49 mjacob sdp->isp_devparam[i].sync_period =
4915 1.49 mjacob ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, i, bus);
4916 1.49 mjacob sdp->isp_devparam[i].dev_flags = 0;
4917 1.49 mjacob if (ISP12160_NVRAM_TGT_RENEG(nvram_data, i, bus))
4918 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_RENEG;
4919 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_ARQ;
4920 1.49 mjacob if (ISP12160_NVRAM_TGT_TQING(nvram_data, i, bus))
4921 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_TQING;
4922 1.49 mjacob if (ISP12160_NVRAM_TGT_SYNC(nvram_data, i, bus))
4923 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_SYNC;
4924 1.49 mjacob if (ISP12160_NVRAM_TGT_WIDE(nvram_data, i, bus))
4925 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_WIDE;
4926 1.49 mjacob if (ISP12160_NVRAM_TGT_PARITY(nvram_data, i, bus))
4927 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_PARITY;
4928 1.49 mjacob if (ISP12160_NVRAM_TGT_DISC(nvram_data, i, bus))
4929 1.49 mjacob sdp->isp_devparam[i].dev_flags |= DPARM_DISC;
4930 1.49 mjacob sdp->isp_devparam[i].cur_dflags = 0;
4931 1.49 mjacob }
4932 1.49 mjacob }
4933 1.49 mjacob
4934 1.49 mjacob static void
4935 1.49 mjacob isp_parse_nvram_2100(isp, nvram_data)
4936 1.49 mjacob struct ispsoftc *isp;
4937 1.49 mjacob u_int8_t *nvram_data;
4938 1.49 mjacob {
4939 1.49 mjacob fcparam *fcp = (fcparam *) isp->isp_param;
4940 1.57 mjacob u_int64_t wwn;
4941 1.49 mjacob
4942 1.49 mjacob /*
4943 1.62 mjacob * There is NVRAM storage for both Port and Node entities-
4944 1.62 mjacob * but the Node entity appears to be unused on all the cards
4945 1.62 mjacob * I can find. However, we should account for this being set
4946 1.62 mjacob * at some point in the future.
4947 1.62 mjacob *
4948 1.62 mjacob * Qlogic WWNs have an NAA of 2, but usually nothing shows up in
4949 1.62 mjacob * bits 48..60. In the case of the 2202, it appears that they do
4950 1.62 mjacob * use bit 48 to distinguish between the two instances on the card.
4951 1.62 mjacob * The 2204, which I've never seen, *probably* extends this method.
4952 1.62 mjacob */
4953 1.62 mjacob wwn = ISP2100_NVRAM_PORT_NAME(nvram_data);
4954 1.62 mjacob if (wwn) {
4955 1.62 mjacob isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
4956 1.62 mjacob (u_int32_t) (wwn >> 32), (u_int32_t) (wwn & 0xffffffff));
4957 1.62 mjacob if ((wwn >> 60) == 0) {
4958 1.62 mjacob wwn |= (((u_int64_t) 2)<< 60);
4959 1.62 mjacob }
4960 1.62 mjacob }
4961 1.62 mjacob fcp->isp_portwwn = wwn;
4962 1.62 mjacob wwn = ISP2100_NVRAM_NODE_NAME(nvram_data);
4963 1.62 mjacob if (wwn) {
4964 1.62 mjacob isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
4965 1.62 mjacob (u_int32_t) (wwn >> 32), (u_int32_t) (wwn & 0xffffffff));
4966 1.62 mjacob if ((wwn >> 60) == 0) {
4967 1.62 mjacob wwn |= (((u_int64_t) 2)<< 60);
4968 1.62 mjacob }
4969 1.62 mjacob }
4970 1.62 mjacob fcp->isp_nodewwn = wwn;
4971 1.62 mjacob
4972 1.62 mjacob /*
4973 1.62 mjacob * Make sure we have both Node and Port as non-zero values.
4974 1.49 mjacob */
4975 1.62 mjacob if (fcp->isp_nodewwn != 0 && fcp->isp_portwwn == 0) {
4976 1.62 mjacob fcp->isp_portwwn = fcp->isp_nodewwn;
4977 1.62 mjacob } else if (fcp->isp_nodewwn == 0 && fcp->isp_portwwn != 0) {
4978 1.62 mjacob fcp->isp_nodewwn = fcp->isp_portwwn;
4979 1.62 mjacob }
4980 1.52 he
4981 1.62 mjacob /*
4982 1.62 mjacob * Make the Node and Port values sane if they're NAA == 2.
4983 1.62 mjacob * This means to clear bits 48..56 for the Node WWN and
4984 1.62 mjacob * make sure that there's some non-zero value in 48..56
4985 1.62 mjacob * for the Port WWN.
4986 1.62 mjacob */
4987 1.62 mjacob if (fcp->isp_nodewwn && fcp->isp_portwwn) {
4988 1.62 mjacob if ((fcp->isp_nodewwn & (((u_int64_t) 0xfff) << 48)) != 0 &&
4989 1.62 mjacob (fcp->isp_nodewwn >> 60) == 2) {
4990 1.62 mjacob fcp->isp_nodewwn &= ~((u_int64_t) 0xfff << 48);
4991 1.62 mjacob }
4992 1.62 mjacob if ((fcp->isp_portwwn & (((u_int64_t) 0xfff) << 48)) == 0 &&
4993 1.62 mjacob (fcp->isp_portwwn >> 60) == 2) {
4994 1.62 mjacob fcp->isp_portwwn |= ((u_int64_t) 1 << 56);
4995 1.52 he }
4996 1.49 mjacob }
4997 1.62 mjacob
4998 1.49 mjacob fcp->isp_maxalloc =
4999 1.49 mjacob ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
5000 1.49 mjacob fcp->isp_maxfrmlen =
5001 1.49 mjacob ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
5002 1.49 mjacob fcp->isp_retry_delay =
5003 1.49 mjacob ISP2100_NVRAM_RETRY_DELAY(nvram_data);
5004 1.49 mjacob fcp->isp_retry_count =
5005 1.49 mjacob ISP2100_NVRAM_RETRY_COUNT(nvram_data);
5006 1.49 mjacob fcp->isp_loopid =
5007 1.49 mjacob ISP2100_NVRAM_HARDLOOPID(nvram_data);
5008 1.49 mjacob fcp->isp_execthrottle =
5009 1.49 mjacob ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
5010 1.49 mjacob fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
5011 1.62 mjacob isp_prt(isp, ISP_LOGDEBUG0,
5012 1.62 mjacob "fwoptions from nvram are 0x%x", fcp->isp_fwoptions);
5013 1.1 cgd }
5014