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