1/*-
2 * Copyright (c) 1997-2006 by Matthew Jacob
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice immediately at the beginning of the file, without modification,
10 * this list of conditions, and the following disclaimer.
11 * 2. The name of the author may not be used to endorse or promote products
12 * derived from this software without specific prior written permission.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
18 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27/*
28 * Machine and OS Independent (well, as best as possible)
29 * code for the Qlogic ISP SCSI and FC-SCSI adapters.
30 */
31
32/*
33 * Inspiration and ideas about this driver are from Erik Moe's Linux driver
34 * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
35 * ideas dredged from the Solaris driver.
36 */
37
38/*
39 * Include header file appropriate for platform we're building on.
40 */
41#ifdef __NetBSD__
42#include <dev/ic/isp_netbsd.h>
43#endif
44#ifdef __FreeBSD__
45#include <sys/cdefs.h>
| 1/*-
2 * Copyright (c) 1997-2006 by Matthew Jacob
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice immediately at the beginning of the file, without modification,
10 * this list of conditions, and the following disclaimer.
11 * 2. The name of the author may not be used to endorse or promote products
12 * derived from this software without specific prior written permission.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
18 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27/*
28 * Machine and OS Independent (well, as best as possible)
29 * code for the Qlogic ISP SCSI and FC-SCSI adapters.
30 */
31
32/*
33 * Inspiration and ideas about this driver are from Erik Moe's Linux driver
34 * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
35 * ideas dredged from the Solaris driver.
36 */
37
38/*
39 * Include header file appropriate for platform we're building on.
40 */
41#ifdef __NetBSD__
42#include <dev/ic/isp_netbsd.h>
43#endif
44#ifdef __FreeBSD__
45#include <sys/cdefs.h>
|
46__FBSDID("$FreeBSD: head/sys/dev/isp/isp.c 166894 2007-02-23 05:39:58Z mjacob $");
| 46__FBSDID("$FreeBSD: head/sys/dev/isp/isp.c 166929 2007-02-23 21:59:21Z mjacob $");
|
47#include <dev/isp/isp_freebsd.h>
48#endif
49#ifdef __OpenBSD__
50#include <dev/ic/isp_openbsd.h>
51#endif
52#ifdef __linux__
53#include "isp_linux.h"
54#endif
55#ifdef __svr4__
56#include "isp_solaris.h"
57#endif
58
59/*
60 * General defines
61 */
62
63#define MBOX_DELAY_COUNT 1000000 / 100
64#define ISP_MARK_PORTDB(a, b) \
65 isp_prt(isp, ISP_LOGSANCFG, "line %d: markportdb", __LINE__); \
66 isp_mark_portdb(a, b)
67
68/*
69 * Local static data
70 */
71static const char fconf[] =
72 "PortDB[%d] changed:\n current =(0x%x@0x%06x 0x%08x%08x 0x%08x%08x)\n"
73 " database=(0x%x@0x%06x 0x%08x%08x 0x%08x%08x)";
74static const char notresp[] =
75 "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d) nlooked %d";
76static const char xact1[] =
77 "HBA attempted queued transaction with disconnect not set for %d.%d.%d";
78static const char xact2[] =
79 "HBA attempted queued transaction to target routine %d on target %d bus %d";
80static const char xact3[] =
81 "HBA attempted queued cmd for %d.%d.%d when queueing disabled";
82static const char pskip[] =
83 "SCSI phase skipped for target %d.%d.%d";
84static const char topology[] =
85 "HBA PortID 0x%06x N-Port Handle %d, Connection Topology '%s'";
86static const char ourwwn[] =
87 "HBA WWNN 0x%08x%08x HBA WWPN 0x%08x%08x";
88static const char finmsg[] =
89 "%d.%d.%d: FIN dl%d resid %d STS 0x%x SKEY %c XS_ERR=0x%x";
90static const char sc0[] =
91 "%s CHAN %d FTHRSH %d IID %d RESETD %d RETRYC %d RETRYD %d ASD 0x%x";
92static const char sc1[] =
93 "%s RAAN 0x%x DLAN 0x%x DDMAB 0x%x CDMAB 0x%x SELTIME %d MQD %d";
94static const char sc2[] = "%s CHAN %d TGT %d FLAGS 0x%x 0x%x/0x%x";
95static const char sc3[] = "Generated";
96static const char sc4[] = "NVRAM";
97static const char bun[] =
98 "bad underrun for %d.%d (count %d, resid %d, status %s)";
99
100/*
101 * Local function prototypes.
102 */
103static int isp_parse_async(ispsoftc_t *, uint16_t);
104static int isp_handle_other_response(ispsoftc_t *, int, isphdr_t *,
105 uint32_t *);
106static void
107isp_parse_status(ispsoftc_t *, ispstatusreq_t *, XS_T *, long *);
108static void
109isp_parse_status_24xx(ispsoftc_t *, isp24xx_statusreq_t *, XS_T *, long *);
110static void isp_fastpost_complete(ispsoftc_t *, uint16_t);
111static int isp_mbox_continue(ispsoftc_t *);
112static void isp_scsi_init(ispsoftc_t *);
113static void isp_scsi_channel_init(ispsoftc_t *, int);
114static void isp_fibre_init(ispsoftc_t *);
115static void isp_fibre_init_2400(ispsoftc_t *);
116static void isp_mark_portdb(ispsoftc_t *, int);
117static int isp_plogx(ispsoftc_t *, uint16_t, uint32_t, int, int);
118static int isp_port_login(ispsoftc_t *, uint16_t, uint32_t);
119static int isp_port_logout(ispsoftc_t *, uint16_t, uint32_t);
120static int isp_getpdb(ispsoftc_t *, uint16_t, isp_pdb_t *, int);
121static uint64_t isp_get_portname(ispsoftc_t *, int, int);
122static int isp_fclink_test(ispsoftc_t *, int);
123static const char *ispfc_fw_statename(int);
124static int isp_pdb_sync(ispsoftc_t *);
125static int isp_scan_loop(ispsoftc_t *);
126static int isp_gid_ft_sns(ispsoftc_t *);
127static int isp_gid_ft_ct_passthru(ispsoftc_t *);
128static int isp_scan_fabric(ispsoftc_t *);
129static int isp_login_device(ispsoftc_t *, uint32_t, isp_pdb_t *, uint16_t *);
130static int isp_register_fc4_type(ispsoftc_t *);
131static int isp_register_fc4_type_24xx(ispsoftc_t *);
132static uint16_t isp_nxt_handle(ispsoftc_t *, uint16_t);
133static void isp_fw_state(ispsoftc_t *);
134static void isp_mboxcmd_qnw(ispsoftc_t *, mbreg_t *, int);
135static void isp_mboxcmd(ispsoftc_t *, mbreg_t *);
136
137static void isp_update(ispsoftc_t *);
138static void isp_update_bus(ispsoftc_t *, int);
139static void isp_setdfltparm(ispsoftc_t *, int);
140static int isp_read_nvram(ispsoftc_t *);
141static int isp_read_nvram_2400(ispsoftc_t *);
142static void isp_rdnvram_word(ispsoftc_t *, int, uint16_t *);
143static void isp_rd_2400_nvram(ispsoftc_t *, uint32_t, uint32_t *);
144static void isp_parse_nvram_1020(ispsoftc_t *, uint8_t *);
145static void isp_parse_nvram_1080(ispsoftc_t *, int, uint8_t *);
146static void isp_parse_nvram_12160(ispsoftc_t *, int, uint8_t *);
147static void isp_fix_nvram_wwns(ispsoftc_t *);
148static void isp_parse_nvram_2100(ispsoftc_t *, uint8_t *);
149static void isp_parse_nvram_2400(ispsoftc_t *, uint8_t *);
150
151/*
152 * Reset Hardware.
153 *
154 * Hit the chip over the head, download new f/w if available and set it running.
155 *
156 * Locking done elsewhere.
157 */
158
159void
160isp_reset(ispsoftc_t *isp)
161{
162 mbreg_t mbs;
163 uint32_t code_org, val;
164 int loops, i, dodnld = 1;
165 static const char *btype = "????";
166 static const char dcrc[] = "Downloaded RISC Code Checksum Failure";
167
168 isp->isp_state = ISP_NILSTATE;
169
170 /*
171 * Basic types (SCSI, FibreChannel and PCI or SBus)
172 * have been set in the MD code. We figure out more
173 * here. Possibly more refined types based upon PCI
174 * identification. Chip revision has been gathered.
175 *
176 * After we've fired this chip up, zero out the conf1 register
177 * for SCSI adapters and do other settings for the 2100.
178 */
179
180 /*
181 * Get the current running firmware revision out of the
182 * chip before we hit it over the head (if this is our
183 * first time through). Note that we store this as the
184 * 'ROM' firmware revision- which it may not be. In any
185 * case, we don't really use this yet, but we may in
186 * the future.
187 */
188 if (isp->isp_touched == 0) {
189 /*
190 * First see whether or not we're sitting in the ISP PROM.
191 * If we've just been reset, we'll have the string "ISP "
192 * spread through outgoing mailbox registers 1-3. We do
193 * this for PCI cards because otherwise we really don't
194 * know what state the card is in and we could hang if
195 * we try this command otherwise.
196 *
197 * For SBus cards, we just do this because they almost
198 * certainly will be running firmware by now.
199 */
200 if (ISP_READ(isp, OUTMAILBOX1) != 0x4953 ||
201 ISP_READ(isp, OUTMAILBOX2) != 0x5020 ||
202 ISP_READ(isp, OUTMAILBOX3) != 0x2020) {
203 /*
204 * Just in case it was paused...
205 */
206 if (IS_24XX(isp)) {
207 ISP_WRITE(isp, BIU2400_HCCR,
208 HCCR_2400_CMD_RELEASE);
209 } else {
210 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
211 }
212 MEMZERO(&mbs, sizeof (mbs));
213 mbs.param[0] = MBOX_ABOUT_FIRMWARE;
214 mbs.logval = MBLOGNONE;
215 isp_mboxcmd(isp, &mbs);
216 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
217 isp->isp_romfw_rev[0] = mbs.param[1];
218 isp->isp_romfw_rev[1] = mbs.param[2];
219 isp->isp_romfw_rev[2] = mbs.param[3];
220 }
221 }
222 isp->isp_touched = 1;
223 }
224
225 ISP_DISABLE_INTS(isp);
226
227 /*
228 * Pick an initial maxcmds value which will be used
229 * to allocate xflist pointer space. It may be changed
230 * later by the firmware.
231 */
232 if (IS_24XX(isp)) {
233 isp->isp_maxcmds = 4096;
234 } else if (IS_2322(isp)) {
235 isp->isp_maxcmds = 2048;
236 } else if (IS_23XX(isp) || IS_2200(isp)) {
237 isp->isp_maxcmds = 1024;
238 } else {
239 isp->isp_maxcmds = 512;
240 }
241
242 /*
243 * Set up DMA for the request and result queues.
244 *
245 * We do this now so we can use the request queue
246 * for a dma
247 */
248 if (ISP_MBOXDMASETUP(isp) != 0) {
249 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
250 return;
251 }
252
253
254 /*
255 * Set up default request/response queue in-pointer/out-pointer
256 * register indices.
257 */
258 if (IS_24XX(isp)) {
259 isp->isp_rqstinrp = BIU2400_REQINP;
260 isp->isp_rqstoutrp = BIU2400_REQOUTP;
261 isp->isp_respinrp = BIU2400_RSPINP;
262 isp->isp_respoutrp = BIU2400_RSPOUTP;
263 isp->isp_atioinrp = BIU2400_ATIO_RSPINP;
264 isp->isp_atiooutrp = BIU2400_ATIO_REQINP;
265 } else if (IS_23XX(isp)) {
266 isp->isp_rqstinrp = BIU_REQINP;
267 isp->isp_rqstoutrp = BIU_REQOUTP;
268 isp->isp_respinrp = BIU_RSPINP;
269 isp->isp_respoutrp = BIU_RSPOUTP;
270 } else {
271 isp->isp_rqstinrp = INMAILBOX4;
272 isp->isp_rqstoutrp = OUTMAILBOX4;
273 isp->isp_respinrp = OUTMAILBOX5;
274 isp->isp_respoutrp = INMAILBOX5;
275 }
276
277 /*
278 * Put the board into PAUSE mode (so we can read the SXP registers
279 * or write FPM/FBM registers).
280 */
281 if (IS_24XX(isp)) {
282 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_HOST_INT);
283 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
284 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
285 } else {
286 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
287 }
288
289 if (IS_FC(isp)) {
290 switch (isp->isp_type) {
291 case ISP_HA_FC_2100:
292 btype = "2100";
293 break;
294 case ISP_HA_FC_2200:
295 btype = "2200";
296 break;
297 case ISP_HA_FC_2300:
298 btype = "2300";
299 break;
300 case ISP_HA_FC_2312:
301 btype = "2312";
302 break;
303 case ISP_HA_FC_2322:
304 btype = "2322";
305 break;
306 case ISP_HA_FC_2400:
307 btype = "2422";
308 break;
309 default:
310 break;
311 }
312
313 if (!IS_24XX(isp)) {
314 /*
315 * While we're paused, reset the FPM module and FBM
316 * fifos.
317 */
318 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
319 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
320 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
321 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
322 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
323 }
324 } else if (IS_1240(isp)) {
325 sdparam *sdp = isp->isp_param;
326 btype = "1240";
327 isp->isp_clock = 60;
328 sdp->isp_ultramode = 1;
329 sdp++;
330 sdp->isp_ultramode = 1;
331 /*
332 * XXX: Should probably do some bus sensing.
333 */
334 } else if (IS_ULTRA2(isp)) {
335 static const char m[] = "bus %d is in %s Mode";
336 uint16_t l;
337 sdparam *sdp = isp->isp_param;
338
339 isp->isp_clock = 100;
340
341 if (IS_1280(isp))
342 btype = "1280";
343 else if (IS_1080(isp))
344 btype = "1080";
345 else if (IS_10160(isp))
346 btype = "10160";
347 else if (IS_12160(isp))
348 btype = "12160";
349 else
350 btype = "<UNKLVD>";
351
352 l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
353 switch (l) {
354 case ISP1080_LVD_MODE:
355 sdp->isp_lvdmode = 1;
356 isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
357 break;
358 case ISP1080_HVD_MODE:
359 sdp->isp_diffmode = 1;
360 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
361 break;
362 case ISP1080_SE_MODE:
363 sdp->isp_ultramode = 1;
364 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
365 break;
366 default:
367 isp_prt(isp, ISP_LOGERR,
368 "unknown mode on bus %d (0x%x)", 0, l);
369 break;
370 }
371
372 if (IS_DUALBUS(isp)) {
373 sdp++;
374 l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
375 l &= ISP1080_MODE_MASK;
376 switch(l) {
377 case ISP1080_LVD_MODE:
378 sdp->isp_lvdmode = 1;
379 isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
380 break;
381 case ISP1080_HVD_MODE:
382 sdp->isp_diffmode = 1;
383 isp_prt(isp, ISP_LOGCONFIG,
384 m, 1, "Differential");
385 break;
386 case ISP1080_SE_MODE:
387 sdp->isp_ultramode = 1;
388 isp_prt(isp, ISP_LOGCONFIG,
389 m, 1, "Single-Ended");
390 break;
391 default:
392 isp_prt(isp, ISP_LOGERR,
393 "unknown mode on bus %d (0x%x)", 1, l);
394 break;
395 }
396 }
397 } else {
398 sdparam *sdp = isp->isp_param;
399 i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
400 switch (i) {
401 default:
402 isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
403 /* FALLTHROUGH */
404 case 1:
405 btype = "1020";
406 isp->isp_type = ISP_HA_SCSI_1020;
407 isp->isp_clock = 40;
408 break;
409 case 2:
410 /*
411 * Some 1020A chips are Ultra Capable, but don't
412 * run the clock rate up for that unless told to
413 * do so by the Ultra Capable bits being set.
414 */
415 btype = "1020A";
416 isp->isp_type = ISP_HA_SCSI_1020A;
417 isp->isp_clock = 40;
418 break;
419 case 3:
420 btype = "1040";
421 isp->isp_type = ISP_HA_SCSI_1040;
422 isp->isp_clock = 60;
423 break;
424 case 4:
425 btype = "1040A";
426 isp->isp_type = ISP_HA_SCSI_1040A;
427 isp->isp_clock = 60;
428 break;
429 case 5:
430 btype = "1040B";
431 isp->isp_type = ISP_HA_SCSI_1040B;
432 isp->isp_clock = 60;
433 break;
434 case 6:
435 btype = "1040C";
436 isp->isp_type = ISP_HA_SCSI_1040C;
437 isp->isp_clock = 60;
438 break;
439 }
440 /*
441 * Now, while we're at it, gather info about ultra
442 * and/or differential mode.
443 */
444 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
445 isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
446 sdp->isp_diffmode = 1;
447 } else {
448 sdp->isp_diffmode = 0;
449 }
450 i = ISP_READ(isp, RISC_PSR);
451 if (isp->isp_bustype == ISP_BT_SBUS) {
452 i &= RISC_PSR_SBUS_ULTRA;
453 } else {
454 i &= RISC_PSR_PCI_ULTRA;
455 }
456 if (i != 0) {
457 isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
458 sdp->isp_ultramode = 1;
459 /*
460 * If we're in Ultra Mode, we have to be 60MHz clock-
461 * even for the SBus version.
462 */
463 isp->isp_clock = 60;
464 } else {
465 sdp->isp_ultramode = 0;
466 /*
467 * Clock is known. Gronk.
468 */
469 }
470
471 /*
472 * Machine dependent clock (if set) overrides
473 * our generic determinations.
474 */
475 if (isp->isp_mdvec->dv_clock) {
476 if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
477 isp->isp_clock = isp->isp_mdvec->dv_clock;
478 }
479 }
480
481 }
482
483 /*
484 * Clear instrumentation
485 */
486 isp->isp_intcnt = isp->isp_intbogus = 0;
487
488 /*
489 * Do MD specific pre initialization
490 */
491 ISP_RESET0(isp);
492
493 /*
494 * Hit the chip over the head with hammer,
495 * and give the ISP a chance to recover.
496 */
497
498 if (IS_SCSI(isp)) {
499 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
500 /*
501 * A slight delay...
502 */
503 USEC_DELAY(100);
504
505 /*
506 * Clear data && control DMA engines.
507 */
508 ISP_WRITE(isp, CDMA_CONTROL,
509 DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
510 ISP_WRITE(isp, DDMA_CONTROL,
511 DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
512
513
514 } else if (IS_24XX(isp)) {
515 /*
516 * Stop DMA and wait for it to stop.
517 */
518 ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
519 for (val = loops = 0; loops < 30000; loops++) {
520 USEC_DELAY(10);
521 val = ISP_READ(isp, BIU2400_CSR);
522 if ((val & BIU2400_DMA_ACTIVE) == 0) {
523 break;
524 }
525 }
526 if (val & BIU2400_DMA_ACTIVE) {
527 ISP_RESET0(isp);
528 isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
529 return;
530 }
531 /*
532 * Hold it in SOFT_RESET and STOP state for 100us.
533 */
534 ISP_WRITE(isp, BIU2400_CSR,
535 BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
536 USEC_DELAY(100);
537 for (loops = 0; loops < 10000; loops++) {
538 USEC_DELAY(5);
539 val = ISP_READ(isp, OUTMAILBOX0);
540 }
541 for (val = loops = 0; loops < 500000; loops ++) {
542 val = ISP_READ(isp, BIU2400_CSR);
543 if ((val & BIU2400_SOFT_RESET) == 0) {
544 break;
545 }
546 }
547 if (val & BIU2400_SOFT_RESET) {
548 ISP_RESET0(isp);
549 isp_prt(isp, ISP_LOGERR, "Failed to come out of reset");
550 return;
551 }
552 } else {
553 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
554 /*
555 * A slight delay...
556 */
557 USEC_DELAY(100);
558
559 /*
560 * Clear data && control DMA engines.
561 */
562 ISP_WRITE(isp, CDMA2100_CONTROL,
563 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
564 ISP_WRITE(isp, TDMA2100_CONTROL,
565 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
566 ISP_WRITE(isp, RDMA2100_CONTROL,
567 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
568 }
569
570 /*
571 * Wait for ISP to be ready to go...
572 */
573 loops = MBOX_DELAY_COUNT;
574 for (;;) {
575 if (IS_SCSI(isp)) {
576 if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) {
577 break;
578 }
579 } else if (IS_24XX(isp)) {
580 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
581 break;
582 }
583 } else {
584 if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
585 break;
586 }
587 USEC_DELAY(100);
588 if (--loops < 0) {
589 ISP_DUMPREGS(isp, "chip reset timed out");
590 ISP_RESET0(isp);
591 return;
592 }
593 }
594
595 /*
596 * After we've fired this chip up, zero out the conf1 register
597 * for SCSI adapters and other settings for the 2100.
598 */
599
600 if (IS_SCSI(isp)) {
601 ISP_WRITE(isp, BIU_CONF1, 0);
602 } else if (!IS_24XX(isp)) {
603 ISP_WRITE(isp, BIU2100_CSR, 0);
604 }
605
606 /*
607 * Reset RISC Processor
608 */
609 if (IS_24XX(isp)) {
610 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
611 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
612 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
613 } else {
614 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
615 USEC_DELAY(100);
616 ISP_WRITE(isp, BIU_SEMA, 0);
617 }
618
619
620 /*
621 * Post-RISC Reset stuff.
622 */
623 if (IS_24XX(isp)) {
624 for (val = loops = 0; loops < 5000000; loops++) {
625 USEC_DELAY(5);
626 val = ISP_READ(isp, OUTMAILBOX0);
627 if (val == 0) {
628 break;
629 }
630 }
631 if (val != 0) {
632 ISP_RESET0(isp);
633 isp_prt(isp, ISP_LOGERR, "reset didn't clear");
634 return;
635 }
636 } else if (IS_SCSI(isp)) {
637 uint16_t tmp = isp->isp_mdvec->dv_conf1;
638 /*
639 * Busted FIFO. Turn off all but burst enables.
640 */
641 if (isp->isp_type == ISP_HA_SCSI_1040A) {
642 tmp &= BIU_BURST_ENABLE;
643 }
644 ISP_SETBITS(isp, BIU_CONF1, tmp);
645 if (tmp & BIU_BURST_ENABLE) {
646 ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
647 ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
648 }
649 if (SDPARAM(isp)->isp_ptisp) {
650 if (SDPARAM(isp)->isp_ultramode) {
651 while (ISP_READ(isp, RISC_MTR) != 0x1313) {
652 ISP_WRITE(isp, RISC_MTR, 0x1313);
653 ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
654 }
655 } else {
656 ISP_WRITE(isp, RISC_MTR, 0x1212);
657 }
658 /*
659 * PTI specific register
660 */
661 ISP_WRITE(isp, RISC_EMB, DUAL_BANK);
662 } else {
663 ISP_WRITE(isp, RISC_MTR, 0x1212);
664 }
665 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
666 } else {
667 ISP_WRITE(isp, RISC_MTR2100, 0x1212);
668 if (IS_2200(isp) || IS_23XX(isp)) {
669 ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
670 }
671 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
672 }
673
674 ISP_WRITE(isp, isp->isp_rqstinrp, 0);
675 ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
676 ISP_WRITE(isp, isp->isp_respinrp, 0);
677 ISP_WRITE(isp, isp->isp_respoutrp, 0);
678
679
680 /*
681 * Do MD specific post initialization
682 */
683 ISP_RESET1(isp);
684
685 /*
686 * Wait for everything to finish firing up.
687 *
688 * Avoid doing this on the 2312 because you can generate a PCI
689 * parity error (chip breakage).
690 */
691 if (IS_2312(isp)) {
692 USEC_DELAY(100);
693 } else {
694 loops = MBOX_DELAY_COUNT;
695 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
696 USEC_DELAY(100);
697 if (--loops < 0) {
698 ISP_RESET0(isp);
699 isp_prt(isp, ISP_LOGERR,
700 "MBOX_BUSY never cleared on reset");
701 return;
702 }
703 }
704 }
705
706 /*
707 * Up until this point we've done everything by just reading or
708 * setting registers. From this point on we rely on at least *some*
709 * kind of firmware running in the card.
710 */
711
712 /*
713 * Do some sanity checking.
714 */
715 MEMZERO(&mbs, sizeof (mbs));
716 mbs.param[0] = MBOX_NO_OP;
717 mbs.logval = MBLOGALL;
718 isp_mboxcmd(isp, &mbs);
719 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
720 ISP_RESET0(isp);
721 return;
722 }
723
724 if (IS_SCSI(isp) || IS_24XX(isp)) {
725 MEMZERO(&mbs, sizeof (mbs));
726 mbs.param[0] = MBOX_MAILBOX_REG_TEST;
727 mbs.param[1] = 0xdead;
728 mbs.param[2] = 0xbeef;
729 mbs.param[3] = 0xffff;
730 mbs.param[4] = 0x1111;
731 mbs.param[5] = 0xa5a5;
732 mbs.param[6] = 0x0000;
733 mbs.param[7] = 0x0000;
734 mbs.logval = MBLOGALL;
735 isp_mboxcmd(isp, &mbs);
736 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
737 ISP_RESET0(isp);
738 return;
739 }
740 if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
741 mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
742 mbs.param[5] != 0xa5a5) {
743 ISP_RESET0(isp);
744 isp_prt(isp, ISP_LOGERR,
745 "Register Test Failed (0x%x 0x%x 0x%x 0x%x 0x%x)",
746 mbs.param[1], mbs.param[2], mbs.param[3],
747 mbs.param[4], mbs.param[5]);
748 return;
749 }
750
751 }
752
753 /*
754 * Download new Firmware, unless requested not to do so.
755 * This is made slightly trickier in some cases where the
756 * firmware of the ROM revision is newer than the revision
757 * compiled into the driver. So, where we used to compare
758 * versions of our f/w and the ROM f/w, now we just see
759 * whether we have f/w at all and whether a config flag
760 * has disabled our download.
761 */
762 if ((isp->isp_mdvec->dv_ispfw == NULL) ||
763 (isp->isp_confopts & ISP_CFG_NORELOAD)) {
764 dodnld = 0;
765 }
766
767 if (IS_24XX(isp)) {
768 code_org = ISP_CODE_ORG_2400;
769 } else if (IS_23XX(isp)) {
770 code_org = ISP_CODE_ORG_2300;
771 } else {
772 code_org = ISP_CODE_ORG;
773 }
774
775 if (dodnld && IS_24XX(isp)) {
776 uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
777
778 /*
779 * NB: Whatever you do do, do *not* issue the VERIFY FIRMWARE
780 * NB: command to the 2400 while loading new firmware. This
781 * NB: causes the new f/w to start and immediately crash back
782 * NB: to the ROM.
783 */
784
785 /*
786 * Keep loading until we run out of f/w.
787 */
788 code_org = ptr[2]; /* 1st load address is our start addr */
789
790 for (;;) {
791 uint32_t la, wi, wl;
792
793 isp_prt(isp, ISP_LOGDEBUG0,
794 "load 0x%x words of code at load address 0x%x",
795 ptr[3], ptr[2]);
796
797 wi = 0;
798 la = ptr[2];
799 wl = ptr[3];
800
801 while (wi < ptr[3]) {
802 uint32_t *cp;
803 uint32_t nw;
804
805 nw = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) >> 2;
806 if (nw > wl) {
807 nw = wl;
808 }
809 cp = isp->isp_rquest;
810 for (i = 0; i < nw; i++) {
811 cp[i] = ptr[wi++];
812 wl--;
813 }
814 MEMORYBARRIER(isp, SYNC_REQUEST,
815 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)));
816 MEMZERO(&mbs, sizeof (mbs));
817 mbs.param[0] = MBOX_LOAD_RISC_RAM;
818 mbs.param[1] = la;
819 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
820 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
821 mbs.param[4] = nw >> 16;
822 mbs.param[5] = nw;
823 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
824 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
825 mbs.param[8] = la >> 16;
826 mbs.logval = MBLOGALL;
827 isp_mboxcmd(isp, &mbs);
828 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
829 isp_prt(isp, ISP_LOGERR,
830 "F/W Risc Ram Load Failed");
831 ISP_RESET0(isp);
832 return;
833 }
834 la += nw;
835 }
836
837 if (ptr[1] == 0) {
838 break;
839 }
840 ptr += ptr[3];
841 }
842 isp->isp_loaded_fw = 1;
843 } else if (dodnld && IS_23XX(isp)) {
844 uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
845 uint16_t wi, wl, segno;
846 uint32_t la;
847
848 la = code_org;
849 segno = 0;
850
851 for (;;) {
852 uint32_t nxtaddr;
853
854 isp_prt(isp, ISP_LOGDEBUG0,
855 "load 0x%x words of code at load address 0x%x",
856 ptr[3], la);
857
858 wi = 0;
859 wl = ptr[3];
860
861 while (wi < ptr[3]) {
862 uint16_t *cp;
863 uint32_t nw;
864
865 nw = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) >> 1;
866 if (nw > wl) {
867 nw = wl;
868 }
869 if (nw > (1 << 15)) {
870 nw = 1 << 15;
871 }
872 cp = isp->isp_rquest;
873 for (i = 0; i < nw; i++) {
874 cp[i] = ptr[wi++];
875 wl--;
876 }
877 MEMORYBARRIER(isp, SYNC_REQUEST,
878 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)));
879 MEMZERO(&mbs, sizeof (mbs));
880 mbs.param[0] = MBOX_LOAD_RISC_RAM;
881 mbs.param[1] = la;
882 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
883 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
884 mbs.param[4] = nw;
885 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
886 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
887 mbs.param[8] = la >> 16;
888 mbs.logval = MBLOGALL;
889 isp_mboxcmd(isp, &mbs);
890 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
891 isp_prt(isp, ISP_LOGERR,
892 "F/W Risc Ram Load Failed");
893 ISP_RESET0(isp);
894 return;
895 }
896 la += nw;
897 }
898
899 if (!IS_2322(isp)) {
900 /*
901 * Verify that it downloaded correctly.
902 */
903 MEMZERO(&mbs, sizeof (mbs));
904 mbs.param[0] = MBOX_VERIFY_CHECKSUM;
905 mbs.param[1] = code_org;
906 mbs.logval = MBLOGNONE;
907 isp_mboxcmd(isp, &mbs);
908 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
909 isp_prt(isp, ISP_LOGERR, dcrc);
910 ISP_RESET0(isp);
911 return;
912 }
913 break;
914 }
915
916 if (++segno == 3) {
917 break;
918 }
919
920 /*
921 * If we're a 2322, the firmware actually comes in
922 * three chunks. We loaded the first at the code_org
923 * address. The other two chunks, which follow right
924 * after each other in memory here, get loaded at
925 * addresses specfied at offset 0x9..0xB.
926 */
927
928 nxtaddr = ptr[3];
929 ptr = &ptr[nxtaddr];
930 la = ptr[5] | ((ptr[4] & 0x3f) << 16);
931 }
932 isp->isp_loaded_fw = 1;
933 } else if (dodnld) {
934 uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
935
936 isp->isp_mbxworkp = &ptr[1];
937 isp->isp_mbxwrk0 = ptr[3] - 1;
938 isp->isp_mbxwrk1 = code_org + 1;
939 MEMZERO(&mbs, sizeof (mbs));
940 mbs.param[0] = MBOX_WRITE_RAM_WORD;
941 mbs.param[1] = code_org;
942 mbs.param[2] = ptr[0];
943 mbs.logval = MBLOGNONE;
944 isp_mboxcmd(isp, &mbs);
945 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
946 isp_prt(isp, ISP_LOGERR,
947 "F/W download failed at word %d",
948 isp->isp_mbxwrk1 - code_org);
949 ISP_RESET0(isp);
950 return;
951 }
952 /*
953 * Verify that it downloaded correctly.
954 */
955 MEMZERO(&mbs, sizeof (mbs));
956 mbs.param[0] = MBOX_VERIFY_CHECKSUM;
957 mbs.param[1] = code_org;
958 mbs.logval = MBLOGNONE;
959 isp_mboxcmd(isp, &mbs);
960 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
961 isp_prt(isp, ISP_LOGERR, dcrc);
962 ISP_RESET0(isp);
963 return;
964 }
965 isp->isp_loaded_fw = 1;
966 } else {
967 isp->isp_loaded_fw = 0;
968 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
969 }
970
971 /*
972 * Now start it rolling.
973 *
974 * If we didn't actually download f/w,
975 * we still need to (re)start it.
976 */
977
978
979 MEMZERO(&mbs, sizeof (mbs));
980 mbs.timeout = 1000000;
981 mbs.param[0] = MBOX_EXEC_FIRMWARE;
982 if (IS_24XX(isp)) {
983 mbs.param[1] = code_org >> 16;
984 mbs.param[2] = code_org;
985 if (isp->isp_loaded_fw) {
986 mbs.param[3] = 0;
987 } else {
988 mbs.param[3] = 1;
989 }
990 } else if (IS_2322(isp)) {
991 mbs.param[1] = code_org;
992 if (isp->isp_loaded_fw) {
993 mbs.param[2] = 0;
994 } else {
995 mbs.param[2] = 1;
996 }
997 } else {
998 mbs.param[1] = code_org;
999 }
1000
1001 mbs.logval = MBLOGALL;
1002 isp_mboxcmd(isp, &mbs);
1003 if (IS_2322(isp) || IS_24XX(isp)) {
1004 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1005 ISP_RESET0(isp);
1006 return;
1007 }
1008 }
1009
1010 /*
1011 * Give it a chance to finish starting up.
1012 */
1013 USEC_DELAY(250000);
1014
1015 if (IS_SCSI(isp)) {
1016 /*
1017 * Set CLOCK RATE, but only if asked to.
1018 */
1019 if (isp->isp_clock) {
1020 mbs.param[0] = MBOX_SET_CLOCK_RATE;
1021 mbs.param[1] = isp->isp_clock;
1022 mbs.logval = MBLOGNONE;
1023 isp_mboxcmd(isp, &mbs);
1024 /* we will try not to care if this fails */
1025 }
1026 }
1027
1028 MEMZERO(&mbs, sizeof (mbs));
1029 mbs.param[0] = MBOX_ABOUT_FIRMWARE;
1030 mbs.logval = MBLOGALL;
1031 isp_mboxcmd(isp, &mbs);
1032 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1033 ISP_RESET0(isp);
1034 return;
1035 }
1036
1037 if (IS_24XX(isp) && mbs.param[1] == 0xdead) {
1038 isp_prt(isp, ISP_LOGERR, "f/w didn't *really* start");
1039 ISP_RESET0(isp);
1040 return;
1041 }
1042
1043 /*
1044 * The SBus firmware that we are using apparently does not return
1045 * major, minor, micro revisions in the mailbox registers, which
1046 * is really, really, annoying.
1047 */
1048 if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) {
1049 if (dodnld) {
1050#ifdef ISP_TARGET_MODE
1051 isp->isp_fwrev[0] = 7;
1052 isp->isp_fwrev[1] = 55;
1053#else
1054 isp->isp_fwrev[0] = 1;
1055 isp->isp_fwrev[1] = 37;
1056#endif
1057 isp->isp_fwrev[2] = 0;
1058 }
1059 } else {
1060 isp->isp_fwrev[0] = mbs.param[1];
1061 isp->isp_fwrev[1] = mbs.param[2];
1062 isp->isp_fwrev[2] = mbs.param[3];
1063 }
1064
1065 isp_prt(isp, ISP_LOGALL,
1066 "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
1067 btype, isp->isp_revision, dodnld? "loaded" : "resident",
1068 isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
1069
1070 if (IS_FC(isp)) {
1071 /*
1072 * We do not believe firmware attributes for 2100 code less
1073 * than 1.17.0, unless it's the firmware we specifically
1074 * are loading.
1075 *
1076 * Note that all 22XX and later f/w is greater than 1.X.0.
1077 */
1078 if ((ISP_FW_OLDER_THAN(isp, 1, 17, 1))) {
1079#ifdef USE_SMALLER_2100_FIRMWARE
1080 FCPARAM(isp)->isp_fwattr = ISP_FW_ATTR_SCCLUN;
1081#else
1082 FCPARAM(isp)->isp_fwattr = 0;
1083#endif
1084 } else {
1085 FCPARAM(isp)->isp_fwattr = mbs.param[6];
1086 isp_prt(isp, ISP_LOGDEBUG0,
1087 "Firmware Attributes = 0x%x", mbs.param[6]);
1088 }
1089 FCPARAM(isp)->isp_2klogin = 0;
1090 FCPARAM(isp)->isp_sccfw = 0;
1091 FCPARAM(isp)->isp_tmode = 0;
1092 if (IS_24XX(isp)) {
1093 FCPARAM(isp)->isp_2klogin = 1;
1094 FCPARAM(isp)->isp_sccfw = 1;
1095 FCPARAM(isp)->isp_tmode = 1;
1096 } else {
1097 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
1098 FCPARAM(isp)->isp_sccfw = 1;
1099 }
1100 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_2KLOGINS) {
1101 FCPARAM(isp)->isp_2klogin = 1;
1102 FCPARAM(isp)->isp_sccfw = 1;
1103 }
1104 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_TMODE) {
1105 FCPARAM(isp)->isp_tmode = 1;
1106 }
1107 }
1108 if (FCPARAM(isp)->isp_2klogin) {
1109 isp_prt(isp, ISP_LOGCONFIG, "2K Logins Supported");
1110 }
1111 }
1112
1113 if (isp->isp_romfw_rev[0] || isp->isp_romfw_rev[1] ||
1114 isp->isp_romfw_rev[2]) {
1115 isp_prt(isp, ISP_LOGCONFIG, "Last F/W revision was %d.%d.%d",
1116 isp->isp_romfw_rev[0], isp->isp_romfw_rev[1],
1117 isp->isp_romfw_rev[2]);
1118 }
1119
1120 if (!IS_24XX(isp)) {
1121 MEMZERO(&mbs, sizeof (mbs));
1122 mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
1123 mbs.logval = MBLOGALL;
1124 isp_mboxcmd(isp, &mbs);
1125 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1126 ISP_RESET0(isp);
1127 return;
1128 }
1129 if (isp->isp_maxcmds >= mbs.param[2]) {
1130 isp->isp_maxcmds = mbs.param[2];
1131 }
1132 }
1133 isp_prt(isp, ISP_LOGCONFIG,
1134 "%d max I/O command limit set", isp->isp_maxcmds);
1135 isp_fw_state(isp);
1136
1137 isp->isp_state = ISP_RESETSTATE;
1138
1139 /*
1140 * Okay- now that we have new firmware running, we now (re)set our
1141 * notion of how many luns we support. This is somewhat tricky because
1142 * if we haven't loaded firmware, we sometimes do not have an easy way
1143 * of knowing how many luns we support.
1144 *
1145 * Expanded lun firmware gives you 32 luns for SCSI cards and
1146 * 16384 luns for Fibre Channel cards.
1147 *
1148 * It turns out that even for QLogic 2100s with ROM 1.10 and above
1149 * we do get a firmware attributes word returned in mailbox register 6.
1150 *
1151 * Because the lun is in a different position in the Request Queue
1152 * Entry structure for Fibre Channel with expanded lun firmware, we
1153 * can only support one lun (lun zero) when we don't know what kind
1154 * of firmware we're running.
1155 */
1156 if (IS_SCSI(isp)) {
1157 if (dodnld) {
1158 if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
1159 isp->isp_maxluns = 32;
1160 } else {
1161 isp->isp_maxluns = 8;
1162 }
1163 } else {
1164 isp->isp_maxluns = 8;
1165 }
1166 } else {
1167 if (FCPARAM(isp)->isp_sccfw) {
1168 isp->isp_maxluns = 16384;
1169 } else {
1170 isp->isp_maxluns = 16;
1171 }
1172 }
1173 /*
1174 * Must do this first to get defaults established.
1175 */
1176 isp_setdfltparm(isp, 0);
1177 if (IS_DUALBUS(isp)) {
1178 isp_setdfltparm(isp, 1);
1179 }
1180
1181}
1182
1183/*
1184 * Initialize Parameters of Hardware to a known state.
1185 *
1186 * Locks are held before coming here.
1187 */
1188
1189void
1190isp_init(ispsoftc_t *isp)
1191{
1192 if (IS_FC(isp)) {
1193 /*
1194 * Do this *before* initializing the firmware.
1195 */
1196 ISP_MARK_PORTDB(isp, 0);
1197 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
1198 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
1199
1200 if (isp->isp_role != ISP_ROLE_NONE) {
1201 if (IS_24XX(isp)) {
1202 isp_fibre_init_2400(isp);
1203 } else {
1204 isp_fibre_init(isp);
1205 }
1206 }
1207 } else {
1208 isp_scsi_init(isp);
1209 }
1210}
1211
1212static void
1213isp_scsi_init(ispsoftc_t *isp)
1214{
1215 sdparam *sdp_chan0, *sdp_chan1;
1216 mbreg_t mbs;
1217
1218 sdp_chan0 = isp->isp_param;
1219 sdp_chan1 = sdp_chan0;
1220 if (IS_DUALBUS(isp)) {
1221 sdp_chan1++;
1222 }
1223
1224 /*
1225 * If we have no role (neither target nor initiator), return.
1226 */
1227 if (isp->isp_role == ISP_ROLE_NONE) {
1228 return;
1229 }
1230
1231 /* First do overall per-card settings. */
1232
1233 /*
1234 * If we have fast memory timing enabled, turn it on.
1235 */
1236 if (sdp_chan0->isp_fast_mttr) {
1237 ISP_WRITE(isp, RISC_MTR, 0x1313);
1238 }
1239
1240 /*
1241 * Set Retry Delay and Count.
1242 * You set both channels at the same time.
1243 */
1244 MEMZERO(&mbs, sizeof (mbs));
1245 mbs.param[0] = MBOX_SET_RETRY_COUNT;
1246 mbs.param[1] = sdp_chan0->isp_retry_count;
1247 mbs.param[2] = sdp_chan0->isp_retry_delay;
1248 mbs.param[6] = sdp_chan1->isp_retry_count;
1249 mbs.param[7] = sdp_chan1->isp_retry_delay;
1250 mbs.logval = MBLOGALL;
1251 isp_mboxcmd(isp, &mbs);
1252 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1253 return;
1254 }
1255
1256 /*
1257 * Set ASYNC DATA SETUP time. This is very important.
1258 */
1259 MEMZERO(&mbs, sizeof (mbs));
1260 mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
1261 mbs.param[1] = sdp_chan0->isp_async_data_setup;
1262 mbs.param[2] = sdp_chan1->isp_async_data_setup;
1263 mbs.logval = MBLOGALL;
1264 isp_mboxcmd(isp, &mbs);
1265 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1266 return;
1267 }
1268
1269 /*
1270 * Set ACTIVE Negation State.
1271 */
1272 MEMZERO(&mbs, sizeof (mbs));
1273 mbs.param[0] = MBOX_SET_ACT_NEG_STATE;
1274 mbs.param[1] =
1275 (sdp_chan0->isp_req_ack_active_neg << 4) |
1276 (sdp_chan0->isp_data_line_active_neg << 5);
1277 mbs.param[2] =
1278 (sdp_chan1->isp_req_ack_active_neg << 4) |
1279 (sdp_chan1->isp_data_line_active_neg << 5);
1280 mbs.logval = MBLOGNONE;
1281 isp_mboxcmd(isp, &mbs);
1282 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1283 isp_prt(isp, ISP_LOGERR,
1284 "failed to set active negation state (%d,%d), (%d,%d)",
1285 sdp_chan0->isp_req_ack_active_neg,
1286 sdp_chan0->isp_data_line_active_neg,
1287 sdp_chan1->isp_req_ack_active_neg,
1288 sdp_chan1->isp_data_line_active_neg);
1289 /*
1290 * But don't return.
1291 */
1292 }
1293
1294 /*
1295 * Set the Tag Aging limit
1296 */
1297 MEMZERO(&mbs, sizeof (mbs));
1298 mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
1299 mbs.param[1] = sdp_chan0->isp_tag_aging;
1300 mbs.param[2] = sdp_chan1->isp_tag_aging;
1301 mbs.logval = MBLOGALL;
1302 isp_mboxcmd(isp, &mbs);
1303 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1304 isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
1305 sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
1306 return;
1307 }
1308
1309 /*
1310 * Set selection timeout.
1311 */
1312 MEMZERO(&mbs, sizeof (mbs));
1313 mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
1314 mbs.param[1] = sdp_chan0->isp_selection_timeout;
1315 mbs.param[2] = sdp_chan1->isp_selection_timeout;
1316 mbs.logval = MBLOGALL;
1317 isp_mboxcmd(isp, &mbs);
1318 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1319 return;
1320 }
1321
1322 /* now do per-channel settings */
1323 isp_scsi_channel_init(isp, 0);
1324 if (IS_DUALBUS(isp))
1325 isp_scsi_channel_init(isp, 1);
1326
1327 /*
1328 * Now enable request/response queues
1329 */
1330
1331 if (IS_ULTRA2(isp) || IS_1240(isp)) {
1332 MEMZERO(&mbs, sizeof (mbs));
1333 mbs.param[0] = MBOX_INIT_RES_QUEUE_A64;
1334 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1335 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1336 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1337 mbs.param[4] = 0;
1338 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1339 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1340 mbs.logval = MBLOGALL;
1341 isp_mboxcmd(isp, &mbs);
1342 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1343 return;
1344 }
1345 isp->isp_residx = mbs.param[5];
1346
1347 MEMZERO(&mbs, sizeof (mbs));
1348 mbs.param[0] = MBOX_INIT_REQ_QUEUE_A64;
1349 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1350 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1351 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1352 mbs.param[5] = 0;
1353 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1354 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1355 mbs.logval = MBLOGALL;
1356 isp_mboxcmd(isp, &mbs);
1357 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1358 return;
1359 }
1360 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1361 } else {
1362 MEMZERO(&mbs, sizeof (mbs));
1363 mbs.param[0] = MBOX_INIT_RES_QUEUE;
1364 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1365 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1366 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1367 mbs.param[4] = 0;
1368 mbs.logval = MBLOGALL;
1369 isp_mboxcmd(isp, &mbs);
1370 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1371 return;
1372 }
1373 isp->isp_residx = mbs.param[5];
1374
1375 MEMZERO(&mbs, sizeof (mbs));
1376 mbs.param[0] = MBOX_INIT_REQ_QUEUE;
1377 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1378 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1379 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1380 mbs.param[5] = 0;
1381 mbs.logval = MBLOGALL;
1382 isp_mboxcmd(isp, &mbs);
1383 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1384 return;
1385 }
1386 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1387 }
1388
1389 /*
1390 * Turn on Fast Posting, LVD transitions
1391 *
1392 * Ultra2 F/W always has had fast posting (and LVD transitions)
1393 *
1394 * Ultra and older (i.e., SBus) cards may not. It's just safer
1395 * to assume not for them.
1396 */
1397
1398 MEMZERO(&mbs, sizeof (mbs));
1399 mbs.param[0] = MBOX_SET_FW_FEATURES;
1400 mbs.param[1] = 0;
1401 if (IS_ULTRA2(isp))
1402 mbs.param[1] |= FW_FEATURE_LVD_NOTIFY;
1403#ifndef ISP_NO_RIO
1404 if (IS_ULTRA2(isp) || IS_1240(isp))
1405 mbs.param[1] |= FW_FEATURE_RIO_16BIT;
1406#else
1407 if (IS_ULTRA2(isp) || IS_1240(isp))
1408 mbs.param[1] |= FW_FEATURE_FAST_POST;
1409#endif
1410 if (mbs.param[1] != 0) {
1411 uint16_t sfeat = mbs.param[1];
1412 mbs.logval = MBLOGALL;
1413 isp_mboxcmd(isp, &mbs);
1414 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1415 isp_prt(isp, ISP_LOGINFO,
1416 "Enabled FW features (0x%x)", sfeat);
1417 }
1418 }
1419
1420 /*
1421 * Let the outer layers decide whether to issue a SCSI bus reset.
1422 */
1423 isp->isp_state = ISP_INITSTATE;
1424}
1425
1426static void
1427isp_scsi_channel_init(ispsoftc_t *isp, int channel)
1428{
1429 sdparam *sdp;
1430 mbreg_t mbs;
1431 int tgt;
1432
1433 sdp = isp->isp_param;
1434 sdp += channel;
1435
1436 /*
1437 * Set (possibly new) Initiator ID.
1438 */
1439 MEMZERO(&mbs, sizeof (mbs));
1440 mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
1441 mbs.param[1] = (channel << 7) | sdp->isp_initiator_id;
1442 mbs.logval = MBLOGALL;
1443 isp_mboxcmd(isp, &mbs);
1444 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1445 return;
1446 }
1447 isp_prt(isp, ISP_LOGINFO, "Initiator ID is %d on Channel %d",
1448 sdp->isp_initiator_id, channel);
1449
1450
1451 /*
1452 * Set current per-target parameters to an initial safe minimum.
1453 */
1454 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1455 int lun;
1456 uint16_t sdf;
1457
1458 if (sdp->isp_devparam[tgt].dev_enable == 0) {
1459 continue;
1460 }
1461#ifndef ISP_TARGET_MODE
1462 sdf = sdp->isp_devparam[tgt].goal_flags;
1463 sdf &= DPARM_SAFE_DFLT;
1464 /*
1465 * It is not quite clear when this changed over so that
1466 * we could force narrow and async for 1000/1020 cards,
1467 * but assume that this is only the case for loaded
1468 * firmware.
1469 */
1470 if (isp->isp_loaded_fw) {
1471 sdf |= DPARM_NARROW | DPARM_ASYNC;
1472 }
1473#else
1474 /*
1475 * The !$*!)$!$)* f/w uses the same index into some
1476 * internal table to decide how to respond to negotiations,
1477 * so if we've said "let's be safe" for ID X, and ID X
1478 * selects *us*, the negotiations will back to 'safe'
1479 * (as in narrow/async). What the f/w *should* do is
1480 * use the initiator id settings to decide how to respond.
1481 */
1482 sdp->isp_devparam[tgt].goal_flags = sdf = DPARM_DEFAULT;
1483#endif
1484 MEMZERO(&mbs, sizeof (mbs));
1485 mbs.param[0] = MBOX_SET_TARGET_PARAMS;
1486 mbs.param[1] = (channel << 15) | (tgt << 8);
1487 mbs.param[2] = sdf;
1488 if ((sdf & DPARM_SYNC) == 0) {
1489 mbs.param[3] = 0;
1490 } else {
1491 mbs.param[3] =
1492 (sdp->isp_devparam[tgt].goal_offset << 8) |
1493 (sdp->isp_devparam[tgt].goal_period);
1494 }
1495 isp_prt(isp, ISP_LOGDEBUG0,
1496 "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
1497 channel, tgt, mbs.param[2], mbs.param[3] >> 8,
1498 mbs.param[3] & 0xff);
1499 mbs.logval = MBLOGNONE;
1500 isp_mboxcmd(isp, &mbs);
1501 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1502 sdf = DPARM_SAFE_DFLT;
1503 MEMZERO(&mbs, sizeof (mbs));
1504 mbs.param[0] = MBOX_SET_TARGET_PARAMS;
1505 mbs.param[1] = (tgt << 8) | (channel << 15);
1506 mbs.param[2] = sdf;
1507 mbs.param[3] = 0;
1508 mbs.logval = MBLOGALL;
1509 isp_mboxcmd(isp, &mbs);
1510 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1511 continue;
1512 }
1513 }
1514
1515 /*
1516 * We don't update any information directly from the f/w
1517 * because we need to run at least one command to cause a
1518 * new state to be latched up. So, we just assume that we
1519 * converge to the values we just had set.
1520 *
1521 * Ensure that we don't believe tagged queuing is enabled yet.
1522 * It turns out that sometimes the ISP just ignores our
1523 * attempts to set parameters for devices that it hasn't
1524 * seen yet.
1525 */
1526 sdp->isp_devparam[tgt].actv_flags = sdf & ~DPARM_TQING;
1527 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1528 MEMZERO(&mbs, sizeof (mbs));
1529 mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
1530 mbs.param[1] = (channel << 15) | (tgt << 8) | lun;
1531 mbs.param[2] = sdp->isp_max_queue_depth;
1532 mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
1533 mbs.logval = MBLOGALL;
1534 isp_mboxcmd(isp, &mbs);
1535 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1536 break;
1537 }
1538 }
1539 }
1540 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1541 if (sdp->isp_devparam[tgt].dev_refresh) {
1542 isp->isp_sendmarker |= (1 << channel);
1543 isp->isp_update |= (1 << channel);
1544 break;
1545 }
1546 }
1547}
1548
1549/*
1550 * Fibre Channel specific initialization.
1551 */
1552static void
1553isp_fibre_init(ispsoftc_t *isp)
1554{
1555 fcparam *fcp;
1556 isp_icb_t local, *icbp = &local;
1557 mbreg_t mbs;
| 47#include <dev/isp/isp_freebsd.h>
48#endif
49#ifdef __OpenBSD__
50#include <dev/ic/isp_openbsd.h>
51#endif
52#ifdef __linux__
53#include "isp_linux.h"
54#endif
55#ifdef __svr4__
56#include "isp_solaris.h"
57#endif
58
59/*
60 * General defines
61 */
62
63#define MBOX_DELAY_COUNT 1000000 / 100
64#define ISP_MARK_PORTDB(a, b) \
65 isp_prt(isp, ISP_LOGSANCFG, "line %d: markportdb", __LINE__); \
66 isp_mark_portdb(a, b)
67
68/*
69 * Local static data
70 */
71static const char fconf[] =
72 "PortDB[%d] changed:\n current =(0x%x@0x%06x 0x%08x%08x 0x%08x%08x)\n"
73 " database=(0x%x@0x%06x 0x%08x%08x 0x%08x%08x)";
74static const char notresp[] =
75 "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d) nlooked %d";
76static const char xact1[] =
77 "HBA attempted queued transaction with disconnect not set for %d.%d.%d";
78static const char xact2[] =
79 "HBA attempted queued transaction to target routine %d on target %d bus %d";
80static const char xact3[] =
81 "HBA attempted queued cmd for %d.%d.%d when queueing disabled";
82static const char pskip[] =
83 "SCSI phase skipped for target %d.%d.%d";
84static const char topology[] =
85 "HBA PortID 0x%06x N-Port Handle %d, Connection Topology '%s'";
86static const char ourwwn[] =
87 "HBA WWNN 0x%08x%08x HBA WWPN 0x%08x%08x";
88static const char finmsg[] =
89 "%d.%d.%d: FIN dl%d resid %d STS 0x%x SKEY %c XS_ERR=0x%x";
90static const char sc0[] =
91 "%s CHAN %d FTHRSH %d IID %d RESETD %d RETRYC %d RETRYD %d ASD 0x%x";
92static const char sc1[] =
93 "%s RAAN 0x%x DLAN 0x%x DDMAB 0x%x CDMAB 0x%x SELTIME %d MQD %d";
94static const char sc2[] = "%s CHAN %d TGT %d FLAGS 0x%x 0x%x/0x%x";
95static const char sc3[] = "Generated";
96static const char sc4[] = "NVRAM";
97static const char bun[] =
98 "bad underrun for %d.%d (count %d, resid %d, status %s)";
99
100/*
101 * Local function prototypes.
102 */
103static int isp_parse_async(ispsoftc_t *, uint16_t);
104static int isp_handle_other_response(ispsoftc_t *, int, isphdr_t *,
105 uint32_t *);
106static void
107isp_parse_status(ispsoftc_t *, ispstatusreq_t *, XS_T *, long *);
108static void
109isp_parse_status_24xx(ispsoftc_t *, isp24xx_statusreq_t *, XS_T *, long *);
110static void isp_fastpost_complete(ispsoftc_t *, uint16_t);
111static int isp_mbox_continue(ispsoftc_t *);
112static void isp_scsi_init(ispsoftc_t *);
113static void isp_scsi_channel_init(ispsoftc_t *, int);
114static void isp_fibre_init(ispsoftc_t *);
115static void isp_fibre_init_2400(ispsoftc_t *);
116static void isp_mark_portdb(ispsoftc_t *, int);
117static int isp_plogx(ispsoftc_t *, uint16_t, uint32_t, int, int);
118static int isp_port_login(ispsoftc_t *, uint16_t, uint32_t);
119static int isp_port_logout(ispsoftc_t *, uint16_t, uint32_t);
120static int isp_getpdb(ispsoftc_t *, uint16_t, isp_pdb_t *, int);
121static uint64_t isp_get_portname(ispsoftc_t *, int, int);
122static int isp_fclink_test(ispsoftc_t *, int);
123static const char *ispfc_fw_statename(int);
124static int isp_pdb_sync(ispsoftc_t *);
125static int isp_scan_loop(ispsoftc_t *);
126static int isp_gid_ft_sns(ispsoftc_t *);
127static int isp_gid_ft_ct_passthru(ispsoftc_t *);
128static int isp_scan_fabric(ispsoftc_t *);
129static int isp_login_device(ispsoftc_t *, uint32_t, isp_pdb_t *, uint16_t *);
130static int isp_register_fc4_type(ispsoftc_t *);
131static int isp_register_fc4_type_24xx(ispsoftc_t *);
132static uint16_t isp_nxt_handle(ispsoftc_t *, uint16_t);
133static void isp_fw_state(ispsoftc_t *);
134static void isp_mboxcmd_qnw(ispsoftc_t *, mbreg_t *, int);
135static void isp_mboxcmd(ispsoftc_t *, mbreg_t *);
136
137static void isp_update(ispsoftc_t *);
138static void isp_update_bus(ispsoftc_t *, int);
139static void isp_setdfltparm(ispsoftc_t *, int);
140static int isp_read_nvram(ispsoftc_t *);
141static int isp_read_nvram_2400(ispsoftc_t *);
142static void isp_rdnvram_word(ispsoftc_t *, int, uint16_t *);
143static void isp_rd_2400_nvram(ispsoftc_t *, uint32_t, uint32_t *);
144static void isp_parse_nvram_1020(ispsoftc_t *, uint8_t *);
145static void isp_parse_nvram_1080(ispsoftc_t *, int, uint8_t *);
146static void isp_parse_nvram_12160(ispsoftc_t *, int, uint8_t *);
147static void isp_fix_nvram_wwns(ispsoftc_t *);
148static void isp_parse_nvram_2100(ispsoftc_t *, uint8_t *);
149static void isp_parse_nvram_2400(ispsoftc_t *, uint8_t *);
150
151/*
152 * Reset Hardware.
153 *
154 * Hit the chip over the head, download new f/w if available and set it running.
155 *
156 * Locking done elsewhere.
157 */
158
159void
160isp_reset(ispsoftc_t *isp)
161{
162 mbreg_t mbs;
163 uint32_t code_org, val;
164 int loops, i, dodnld = 1;
165 static const char *btype = "????";
166 static const char dcrc[] = "Downloaded RISC Code Checksum Failure";
167
168 isp->isp_state = ISP_NILSTATE;
169
170 /*
171 * Basic types (SCSI, FibreChannel and PCI or SBus)
172 * have been set in the MD code. We figure out more
173 * here. Possibly more refined types based upon PCI
174 * identification. Chip revision has been gathered.
175 *
176 * After we've fired this chip up, zero out the conf1 register
177 * for SCSI adapters and do other settings for the 2100.
178 */
179
180 /*
181 * Get the current running firmware revision out of the
182 * chip before we hit it over the head (if this is our
183 * first time through). Note that we store this as the
184 * 'ROM' firmware revision- which it may not be. In any
185 * case, we don't really use this yet, but we may in
186 * the future.
187 */
188 if (isp->isp_touched == 0) {
189 /*
190 * First see whether or not we're sitting in the ISP PROM.
191 * If we've just been reset, we'll have the string "ISP "
192 * spread through outgoing mailbox registers 1-3. We do
193 * this for PCI cards because otherwise we really don't
194 * know what state the card is in and we could hang if
195 * we try this command otherwise.
196 *
197 * For SBus cards, we just do this because they almost
198 * certainly will be running firmware by now.
199 */
200 if (ISP_READ(isp, OUTMAILBOX1) != 0x4953 ||
201 ISP_READ(isp, OUTMAILBOX2) != 0x5020 ||
202 ISP_READ(isp, OUTMAILBOX3) != 0x2020) {
203 /*
204 * Just in case it was paused...
205 */
206 if (IS_24XX(isp)) {
207 ISP_WRITE(isp, BIU2400_HCCR,
208 HCCR_2400_CMD_RELEASE);
209 } else {
210 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
211 }
212 MEMZERO(&mbs, sizeof (mbs));
213 mbs.param[0] = MBOX_ABOUT_FIRMWARE;
214 mbs.logval = MBLOGNONE;
215 isp_mboxcmd(isp, &mbs);
216 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
217 isp->isp_romfw_rev[0] = mbs.param[1];
218 isp->isp_romfw_rev[1] = mbs.param[2];
219 isp->isp_romfw_rev[2] = mbs.param[3];
220 }
221 }
222 isp->isp_touched = 1;
223 }
224
225 ISP_DISABLE_INTS(isp);
226
227 /*
228 * Pick an initial maxcmds value which will be used
229 * to allocate xflist pointer space. It may be changed
230 * later by the firmware.
231 */
232 if (IS_24XX(isp)) {
233 isp->isp_maxcmds = 4096;
234 } else if (IS_2322(isp)) {
235 isp->isp_maxcmds = 2048;
236 } else if (IS_23XX(isp) || IS_2200(isp)) {
237 isp->isp_maxcmds = 1024;
238 } else {
239 isp->isp_maxcmds = 512;
240 }
241
242 /*
243 * Set up DMA for the request and result queues.
244 *
245 * We do this now so we can use the request queue
246 * for a dma
247 */
248 if (ISP_MBOXDMASETUP(isp) != 0) {
249 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
250 return;
251 }
252
253
254 /*
255 * Set up default request/response queue in-pointer/out-pointer
256 * register indices.
257 */
258 if (IS_24XX(isp)) {
259 isp->isp_rqstinrp = BIU2400_REQINP;
260 isp->isp_rqstoutrp = BIU2400_REQOUTP;
261 isp->isp_respinrp = BIU2400_RSPINP;
262 isp->isp_respoutrp = BIU2400_RSPOUTP;
263 isp->isp_atioinrp = BIU2400_ATIO_RSPINP;
264 isp->isp_atiooutrp = BIU2400_ATIO_REQINP;
265 } else if (IS_23XX(isp)) {
266 isp->isp_rqstinrp = BIU_REQINP;
267 isp->isp_rqstoutrp = BIU_REQOUTP;
268 isp->isp_respinrp = BIU_RSPINP;
269 isp->isp_respoutrp = BIU_RSPOUTP;
270 } else {
271 isp->isp_rqstinrp = INMAILBOX4;
272 isp->isp_rqstoutrp = OUTMAILBOX4;
273 isp->isp_respinrp = OUTMAILBOX5;
274 isp->isp_respoutrp = INMAILBOX5;
275 }
276
277 /*
278 * Put the board into PAUSE mode (so we can read the SXP registers
279 * or write FPM/FBM registers).
280 */
281 if (IS_24XX(isp)) {
282 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_HOST_INT);
283 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
284 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
285 } else {
286 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
287 }
288
289 if (IS_FC(isp)) {
290 switch (isp->isp_type) {
291 case ISP_HA_FC_2100:
292 btype = "2100";
293 break;
294 case ISP_HA_FC_2200:
295 btype = "2200";
296 break;
297 case ISP_HA_FC_2300:
298 btype = "2300";
299 break;
300 case ISP_HA_FC_2312:
301 btype = "2312";
302 break;
303 case ISP_HA_FC_2322:
304 btype = "2322";
305 break;
306 case ISP_HA_FC_2400:
307 btype = "2422";
308 break;
309 default:
310 break;
311 }
312
313 if (!IS_24XX(isp)) {
314 /*
315 * While we're paused, reset the FPM module and FBM
316 * fifos.
317 */
318 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
319 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
320 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
321 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
322 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
323 }
324 } else if (IS_1240(isp)) {
325 sdparam *sdp = isp->isp_param;
326 btype = "1240";
327 isp->isp_clock = 60;
328 sdp->isp_ultramode = 1;
329 sdp++;
330 sdp->isp_ultramode = 1;
331 /*
332 * XXX: Should probably do some bus sensing.
333 */
334 } else if (IS_ULTRA2(isp)) {
335 static const char m[] = "bus %d is in %s Mode";
336 uint16_t l;
337 sdparam *sdp = isp->isp_param;
338
339 isp->isp_clock = 100;
340
341 if (IS_1280(isp))
342 btype = "1280";
343 else if (IS_1080(isp))
344 btype = "1080";
345 else if (IS_10160(isp))
346 btype = "10160";
347 else if (IS_12160(isp))
348 btype = "12160";
349 else
350 btype = "<UNKLVD>";
351
352 l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
353 switch (l) {
354 case ISP1080_LVD_MODE:
355 sdp->isp_lvdmode = 1;
356 isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
357 break;
358 case ISP1080_HVD_MODE:
359 sdp->isp_diffmode = 1;
360 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
361 break;
362 case ISP1080_SE_MODE:
363 sdp->isp_ultramode = 1;
364 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
365 break;
366 default:
367 isp_prt(isp, ISP_LOGERR,
368 "unknown mode on bus %d (0x%x)", 0, l);
369 break;
370 }
371
372 if (IS_DUALBUS(isp)) {
373 sdp++;
374 l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
375 l &= ISP1080_MODE_MASK;
376 switch(l) {
377 case ISP1080_LVD_MODE:
378 sdp->isp_lvdmode = 1;
379 isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
380 break;
381 case ISP1080_HVD_MODE:
382 sdp->isp_diffmode = 1;
383 isp_prt(isp, ISP_LOGCONFIG,
384 m, 1, "Differential");
385 break;
386 case ISP1080_SE_MODE:
387 sdp->isp_ultramode = 1;
388 isp_prt(isp, ISP_LOGCONFIG,
389 m, 1, "Single-Ended");
390 break;
391 default:
392 isp_prt(isp, ISP_LOGERR,
393 "unknown mode on bus %d (0x%x)", 1, l);
394 break;
395 }
396 }
397 } else {
398 sdparam *sdp = isp->isp_param;
399 i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
400 switch (i) {
401 default:
402 isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
403 /* FALLTHROUGH */
404 case 1:
405 btype = "1020";
406 isp->isp_type = ISP_HA_SCSI_1020;
407 isp->isp_clock = 40;
408 break;
409 case 2:
410 /*
411 * Some 1020A chips are Ultra Capable, but don't
412 * run the clock rate up for that unless told to
413 * do so by the Ultra Capable bits being set.
414 */
415 btype = "1020A";
416 isp->isp_type = ISP_HA_SCSI_1020A;
417 isp->isp_clock = 40;
418 break;
419 case 3:
420 btype = "1040";
421 isp->isp_type = ISP_HA_SCSI_1040;
422 isp->isp_clock = 60;
423 break;
424 case 4:
425 btype = "1040A";
426 isp->isp_type = ISP_HA_SCSI_1040A;
427 isp->isp_clock = 60;
428 break;
429 case 5:
430 btype = "1040B";
431 isp->isp_type = ISP_HA_SCSI_1040B;
432 isp->isp_clock = 60;
433 break;
434 case 6:
435 btype = "1040C";
436 isp->isp_type = ISP_HA_SCSI_1040C;
437 isp->isp_clock = 60;
438 break;
439 }
440 /*
441 * Now, while we're at it, gather info about ultra
442 * and/or differential mode.
443 */
444 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
445 isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
446 sdp->isp_diffmode = 1;
447 } else {
448 sdp->isp_diffmode = 0;
449 }
450 i = ISP_READ(isp, RISC_PSR);
451 if (isp->isp_bustype == ISP_BT_SBUS) {
452 i &= RISC_PSR_SBUS_ULTRA;
453 } else {
454 i &= RISC_PSR_PCI_ULTRA;
455 }
456 if (i != 0) {
457 isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
458 sdp->isp_ultramode = 1;
459 /*
460 * If we're in Ultra Mode, we have to be 60MHz clock-
461 * even for the SBus version.
462 */
463 isp->isp_clock = 60;
464 } else {
465 sdp->isp_ultramode = 0;
466 /*
467 * Clock is known. Gronk.
468 */
469 }
470
471 /*
472 * Machine dependent clock (if set) overrides
473 * our generic determinations.
474 */
475 if (isp->isp_mdvec->dv_clock) {
476 if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
477 isp->isp_clock = isp->isp_mdvec->dv_clock;
478 }
479 }
480
481 }
482
483 /*
484 * Clear instrumentation
485 */
486 isp->isp_intcnt = isp->isp_intbogus = 0;
487
488 /*
489 * Do MD specific pre initialization
490 */
491 ISP_RESET0(isp);
492
493 /*
494 * Hit the chip over the head with hammer,
495 * and give the ISP a chance to recover.
496 */
497
498 if (IS_SCSI(isp)) {
499 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
500 /*
501 * A slight delay...
502 */
503 USEC_DELAY(100);
504
505 /*
506 * Clear data && control DMA engines.
507 */
508 ISP_WRITE(isp, CDMA_CONTROL,
509 DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
510 ISP_WRITE(isp, DDMA_CONTROL,
511 DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
512
513
514 } else if (IS_24XX(isp)) {
515 /*
516 * Stop DMA and wait for it to stop.
517 */
518 ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
519 for (val = loops = 0; loops < 30000; loops++) {
520 USEC_DELAY(10);
521 val = ISP_READ(isp, BIU2400_CSR);
522 if ((val & BIU2400_DMA_ACTIVE) == 0) {
523 break;
524 }
525 }
526 if (val & BIU2400_DMA_ACTIVE) {
527 ISP_RESET0(isp);
528 isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
529 return;
530 }
531 /*
532 * Hold it in SOFT_RESET and STOP state for 100us.
533 */
534 ISP_WRITE(isp, BIU2400_CSR,
535 BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
536 USEC_DELAY(100);
537 for (loops = 0; loops < 10000; loops++) {
538 USEC_DELAY(5);
539 val = ISP_READ(isp, OUTMAILBOX0);
540 }
541 for (val = loops = 0; loops < 500000; loops ++) {
542 val = ISP_READ(isp, BIU2400_CSR);
543 if ((val & BIU2400_SOFT_RESET) == 0) {
544 break;
545 }
546 }
547 if (val & BIU2400_SOFT_RESET) {
548 ISP_RESET0(isp);
549 isp_prt(isp, ISP_LOGERR, "Failed to come out of reset");
550 return;
551 }
552 } else {
553 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
554 /*
555 * A slight delay...
556 */
557 USEC_DELAY(100);
558
559 /*
560 * Clear data && control DMA engines.
561 */
562 ISP_WRITE(isp, CDMA2100_CONTROL,
563 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
564 ISP_WRITE(isp, TDMA2100_CONTROL,
565 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
566 ISP_WRITE(isp, RDMA2100_CONTROL,
567 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
568 }
569
570 /*
571 * Wait for ISP to be ready to go...
572 */
573 loops = MBOX_DELAY_COUNT;
574 for (;;) {
575 if (IS_SCSI(isp)) {
576 if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) {
577 break;
578 }
579 } else if (IS_24XX(isp)) {
580 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
581 break;
582 }
583 } else {
584 if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
585 break;
586 }
587 USEC_DELAY(100);
588 if (--loops < 0) {
589 ISP_DUMPREGS(isp, "chip reset timed out");
590 ISP_RESET0(isp);
591 return;
592 }
593 }
594
595 /*
596 * After we've fired this chip up, zero out the conf1 register
597 * for SCSI adapters and other settings for the 2100.
598 */
599
600 if (IS_SCSI(isp)) {
601 ISP_WRITE(isp, BIU_CONF1, 0);
602 } else if (!IS_24XX(isp)) {
603 ISP_WRITE(isp, BIU2100_CSR, 0);
604 }
605
606 /*
607 * Reset RISC Processor
608 */
609 if (IS_24XX(isp)) {
610 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
611 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
612 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
613 } else {
614 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
615 USEC_DELAY(100);
616 ISP_WRITE(isp, BIU_SEMA, 0);
617 }
618
619
620 /*
621 * Post-RISC Reset stuff.
622 */
623 if (IS_24XX(isp)) {
624 for (val = loops = 0; loops < 5000000; loops++) {
625 USEC_DELAY(5);
626 val = ISP_READ(isp, OUTMAILBOX0);
627 if (val == 0) {
628 break;
629 }
630 }
631 if (val != 0) {
632 ISP_RESET0(isp);
633 isp_prt(isp, ISP_LOGERR, "reset didn't clear");
634 return;
635 }
636 } else if (IS_SCSI(isp)) {
637 uint16_t tmp = isp->isp_mdvec->dv_conf1;
638 /*
639 * Busted FIFO. Turn off all but burst enables.
640 */
641 if (isp->isp_type == ISP_HA_SCSI_1040A) {
642 tmp &= BIU_BURST_ENABLE;
643 }
644 ISP_SETBITS(isp, BIU_CONF1, tmp);
645 if (tmp & BIU_BURST_ENABLE) {
646 ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
647 ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
648 }
649 if (SDPARAM(isp)->isp_ptisp) {
650 if (SDPARAM(isp)->isp_ultramode) {
651 while (ISP_READ(isp, RISC_MTR) != 0x1313) {
652 ISP_WRITE(isp, RISC_MTR, 0x1313);
653 ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
654 }
655 } else {
656 ISP_WRITE(isp, RISC_MTR, 0x1212);
657 }
658 /*
659 * PTI specific register
660 */
661 ISP_WRITE(isp, RISC_EMB, DUAL_BANK);
662 } else {
663 ISP_WRITE(isp, RISC_MTR, 0x1212);
664 }
665 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
666 } else {
667 ISP_WRITE(isp, RISC_MTR2100, 0x1212);
668 if (IS_2200(isp) || IS_23XX(isp)) {
669 ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
670 }
671 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
672 }
673
674 ISP_WRITE(isp, isp->isp_rqstinrp, 0);
675 ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
676 ISP_WRITE(isp, isp->isp_respinrp, 0);
677 ISP_WRITE(isp, isp->isp_respoutrp, 0);
678
679
680 /*
681 * Do MD specific post initialization
682 */
683 ISP_RESET1(isp);
684
685 /*
686 * Wait for everything to finish firing up.
687 *
688 * Avoid doing this on the 2312 because you can generate a PCI
689 * parity error (chip breakage).
690 */
691 if (IS_2312(isp)) {
692 USEC_DELAY(100);
693 } else {
694 loops = MBOX_DELAY_COUNT;
695 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
696 USEC_DELAY(100);
697 if (--loops < 0) {
698 ISP_RESET0(isp);
699 isp_prt(isp, ISP_LOGERR,
700 "MBOX_BUSY never cleared on reset");
701 return;
702 }
703 }
704 }
705
706 /*
707 * Up until this point we've done everything by just reading or
708 * setting registers. From this point on we rely on at least *some*
709 * kind of firmware running in the card.
710 */
711
712 /*
713 * Do some sanity checking.
714 */
715 MEMZERO(&mbs, sizeof (mbs));
716 mbs.param[0] = MBOX_NO_OP;
717 mbs.logval = MBLOGALL;
718 isp_mboxcmd(isp, &mbs);
719 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
720 ISP_RESET0(isp);
721 return;
722 }
723
724 if (IS_SCSI(isp) || IS_24XX(isp)) {
725 MEMZERO(&mbs, sizeof (mbs));
726 mbs.param[0] = MBOX_MAILBOX_REG_TEST;
727 mbs.param[1] = 0xdead;
728 mbs.param[2] = 0xbeef;
729 mbs.param[3] = 0xffff;
730 mbs.param[4] = 0x1111;
731 mbs.param[5] = 0xa5a5;
732 mbs.param[6] = 0x0000;
733 mbs.param[7] = 0x0000;
734 mbs.logval = MBLOGALL;
735 isp_mboxcmd(isp, &mbs);
736 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
737 ISP_RESET0(isp);
738 return;
739 }
740 if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
741 mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
742 mbs.param[5] != 0xa5a5) {
743 ISP_RESET0(isp);
744 isp_prt(isp, ISP_LOGERR,
745 "Register Test Failed (0x%x 0x%x 0x%x 0x%x 0x%x)",
746 mbs.param[1], mbs.param[2], mbs.param[3],
747 mbs.param[4], mbs.param[5]);
748 return;
749 }
750
751 }
752
753 /*
754 * Download new Firmware, unless requested not to do so.
755 * This is made slightly trickier in some cases where the
756 * firmware of the ROM revision is newer than the revision
757 * compiled into the driver. So, where we used to compare
758 * versions of our f/w and the ROM f/w, now we just see
759 * whether we have f/w at all and whether a config flag
760 * has disabled our download.
761 */
762 if ((isp->isp_mdvec->dv_ispfw == NULL) ||
763 (isp->isp_confopts & ISP_CFG_NORELOAD)) {
764 dodnld = 0;
765 }
766
767 if (IS_24XX(isp)) {
768 code_org = ISP_CODE_ORG_2400;
769 } else if (IS_23XX(isp)) {
770 code_org = ISP_CODE_ORG_2300;
771 } else {
772 code_org = ISP_CODE_ORG;
773 }
774
775 if (dodnld && IS_24XX(isp)) {
776 uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
777
778 /*
779 * NB: Whatever you do do, do *not* issue the VERIFY FIRMWARE
780 * NB: command to the 2400 while loading new firmware. This
781 * NB: causes the new f/w to start and immediately crash back
782 * NB: to the ROM.
783 */
784
785 /*
786 * Keep loading until we run out of f/w.
787 */
788 code_org = ptr[2]; /* 1st load address is our start addr */
789
790 for (;;) {
791 uint32_t la, wi, wl;
792
793 isp_prt(isp, ISP_LOGDEBUG0,
794 "load 0x%x words of code at load address 0x%x",
795 ptr[3], ptr[2]);
796
797 wi = 0;
798 la = ptr[2];
799 wl = ptr[3];
800
801 while (wi < ptr[3]) {
802 uint32_t *cp;
803 uint32_t nw;
804
805 nw = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) >> 2;
806 if (nw > wl) {
807 nw = wl;
808 }
809 cp = isp->isp_rquest;
810 for (i = 0; i < nw; i++) {
811 cp[i] = ptr[wi++];
812 wl--;
813 }
814 MEMORYBARRIER(isp, SYNC_REQUEST,
815 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)));
816 MEMZERO(&mbs, sizeof (mbs));
817 mbs.param[0] = MBOX_LOAD_RISC_RAM;
818 mbs.param[1] = la;
819 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
820 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
821 mbs.param[4] = nw >> 16;
822 mbs.param[5] = nw;
823 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
824 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
825 mbs.param[8] = la >> 16;
826 mbs.logval = MBLOGALL;
827 isp_mboxcmd(isp, &mbs);
828 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
829 isp_prt(isp, ISP_LOGERR,
830 "F/W Risc Ram Load Failed");
831 ISP_RESET0(isp);
832 return;
833 }
834 la += nw;
835 }
836
837 if (ptr[1] == 0) {
838 break;
839 }
840 ptr += ptr[3];
841 }
842 isp->isp_loaded_fw = 1;
843 } else if (dodnld && IS_23XX(isp)) {
844 uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
845 uint16_t wi, wl, segno;
846 uint32_t la;
847
848 la = code_org;
849 segno = 0;
850
851 for (;;) {
852 uint32_t nxtaddr;
853
854 isp_prt(isp, ISP_LOGDEBUG0,
855 "load 0x%x words of code at load address 0x%x",
856 ptr[3], la);
857
858 wi = 0;
859 wl = ptr[3];
860
861 while (wi < ptr[3]) {
862 uint16_t *cp;
863 uint32_t nw;
864
865 nw = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) >> 1;
866 if (nw > wl) {
867 nw = wl;
868 }
869 if (nw > (1 << 15)) {
870 nw = 1 << 15;
871 }
872 cp = isp->isp_rquest;
873 for (i = 0; i < nw; i++) {
874 cp[i] = ptr[wi++];
875 wl--;
876 }
877 MEMORYBARRIER(isp, SYNC_REQUEST,
878 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)));
879 MEMZERO(&mbs, sizeof (mbs));
880 mbs.param[0] = MBOX_LOAD_RISC_RAM;
881 mbs.param[1] = la;
882 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
883 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
884 mbs.param[4] = nw;
885 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
886 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
887 mbs.param[8] = la >> 16;
888 mbs.logval = MBLOGALL;
889 isp_mboxcmd(isp, &mbs);
890 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
891 isp_prt(isp, ISP_LOGERR,
892 "F/W Risc Ram Load Failed");
893 ISP_RESET0(isp);
894 return;
895 }
896 la += nw;
897 }
898
899 if (!IS_2322(isp)) {
900 /*
901 * Verify that it downloaded correctly.
902 */
903 MEMZERO(&mbs, sizeof (mbs));
904 mbs.param[0] = MBOX_VERIFY_CHECKSUM;
905 mbs.param[1] = code_org;
906 mbs.logval = MBLOGNONE;
907 isp_mboxcmd(isp, &mbs);
908 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
909 isp_prt(isp, ISP_LOGERR, dcrc);
910 ISP_RESET0(isp);
911 return;
912 }
913 break;
914 }
915
916 if (++segno == 3) {
917 break;
918 }
919
920 /*
921 * If we're a 2322, the firmware actually comes in
922 * three chunks. We loaded the first at the code_org
923 * address. The other two chunks, which follow right
924 * after each other in memory here, get loaded at
925 * addresses specfied at offset 0x9..0xB.
926 */
927
928 nxtaddr = ptr[3];
929 ptr = &ptr[nxtaddr];
930 la = ptr[5] | ((ptr[4] & 0x3f) << 16);
931 }
932 isp->isp_loaded_fw = 1;
933 } else if (dodnld) {
934 uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
935
936 isp->isp_mbxworkp = &ptr[1];
937 isp->isp_mbxwrk0 = ptr[3] - 1;
938 isp->isp_mbxwrk1 = code_org + 1;
939 MEMZERO(&mbs, sizeof (mbs));
940 mbs.param[0] = MBOX_WRITE_RAM_WORD;
941 mbs.param[1] = code_org;
942 mbs.param[2] = ptr[0];
943 mbs.logval = MBLOGNONE;
944 isp_mboxcmd(isp, &mbs);
945 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
946 isp_prt(isp, ISP_LOGERR,
947 "F/W download failed at word %d",
948 isp->isp_mbxwrk1 - code_org);
949 ISP_RESET0(isp);
950 return;
951 }
952 /*
953 * Verify that it downloaded correctly.
954 */
955 MEMZERO(&mbs, sizeof (mbs));
956 mbs.param[0] = MBOX_VERIFY_CHECKSUM;
957 mbs.param[1] = code_org;
958 mbs.logval = MBLOGNONE;
959 isp_mboxcmd(isp, &mbs);
960 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
961 isp_prt(isp, ISP_LOGERR, dcrc);
962 ISP_RESET0(isp);
963 return;
964 }
965 isp->isp_loaded_fw = 1;
966 } else {
967 isp->isp_loaded_fw = 0;
968 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
969 }
970
971 /*
972 * Now start it rolling.
973 *
974 * If we didn't actually download f/w,
975 * we still need to (re)start it.
976 */
977
978
979 MEMZERO(&mbs, sizeof (mbs));
980 mbs.timeout = 1000000;
981 mbs.param[0] = MBOX_EXEC_FIRMWARE;
982 if (IS_24XX(isp)) {
983 mbs.param[1] = code_org >> 16;
984 mbs.param[2] = code_org;
985 if (isp->isp_loaded_fw) {
986 mbs.param[3] = 0;
987 } else {
988 mbs.param[3] = 1;
989 }
990 } else if (IS_2322(isp)) {
991 mbs.param[1] = code_org;
992 if (isp->isp_loaded_fw) {
993 mbs.param[2] = 0;
994 } else {
995 mbs.param[2] = 1;
996 }
997 } else {
998 mbs.param[1] = code_org;
999 }
1000
1001 mbs.logval = MBLOGALL;
1002 isp_mboxcmd(isp, &mbs);
1003 if (IS_2322(isp) || IS_24XX(isp)) {
1004 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1005 ISP_RESET0(isp);
1006 return;
1007 }
1008 }
1009
1010 /*
1011 * Give it a chance to finish starting up.
1012 */
1013 USEC_DELAY(250000);
1014
1015 if (IS_SCSI(isp)) {
1016 /*
1017 * Set CLOCK RATE, but only if asked to.
1018 */
1019 if (isp->isp_clock) {
1020 mbs.param[0] = MBOX_SET_CLOCK_RATE;
1021 mbs.param[1] = isp->isp_clock;
1022 mbs.logval = MBLOGNONE;
1023 isp_mboxcmd(isp, &mbs);
1024 /* we will try not to care if this fails */
1025 }
1026 }
1027
1028 MEMZERO(&mbs, sizeof (mbs));
1029 mbs.param[0] = MBOX_ABOUT_FIRMWARE;
1030 mbs.logval = MBLOGALL;
1031 isp_mboxcmd(isp, &mbs);
1032 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1033 ISP_RESET0(isp);
1034 return;
1035 }
1036
1037 if (IS_24XX(isp) && mbs.param[1] == 0xdead) {
1038 isp_prt(isp, ISP_LOGERR, "f/w didn't *really* start");
1039 ISP_RESET0(isp);
1040 return;
1041 }
1042
1043 /*
1044 * The SBus firmware that we are using apparently does not return
1045 * major, minor, micro revisions in the mailbox registers, which
1046 * is really, really, annoying.
1047 */
1048 if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) {
1049 if (dodnld) {
1050#ifdef ISP_TARGET_MODE
1051 isp->isp_fwrev[0] = 7;
1052 isp->isp_fwrev[1] = 55;
1053#else
1054 isp->isp_fwrev[0] = 1;
1055 isp->isp_fwrev[1] = 37;
1056#endif
1057 isp->isp_fwrev[2] = 0;
1058 }
1059 } else {
1060 isp->isp_fwrev[0] = mbs.param[1];
1061 isp->isp_fwrev[1] = mbs.param[2];
1062 isp->isp_fwrev[2] = mbs.param[3];
1063 }
1064
1065 isp_prt(isp, ISP_LOGALL,
1066 "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
1067 btype, isp->isp_revision, dodnld? "loaded" : "resident",
1068 isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
1069
1070 if (IS_FC(isp)) {
1071 /*
1072 * We do not believe firmware attributes for 2100 code less
1073 * than 1.17.0, unless it's the firmware we specifically
1074 * are loading.
1075 *
1076 * Note that all 22XX and later f/w is greater than 1.X.0.
1077 */
1078 if ((ISP_FW_OLDER_THAN(isp, 1, 17, 1))) {
1079#ifdef USE_SMALLER_2100_FIRMWARE
1080 FCPARAM(isp)->isp_fwattr = ISP_FW_ATTR_SCCLUN;
1081#else
1082 FCPARAM(isp)->isp_fwattr = 0;
1083#endif
1084 } else {
1085 FCPARAM(isp)->isp_fwattr = mbs.param[6];
1086 isp_prt(isp, ISP_LOGDEBUG0,
1087 "Firmware Attributes = 0x%x", mbs.param[6]);
1088 }
1089 FCPARAM(isp)->isp_2klogin = 0;
1090 FCPARAM(isp)->isp_sccfw = 0;
1091 FCPARAM(isp)->isp_tmode = 0;
1092 if (IS_24XX(isp)) {
1093 FCPARAM(isp)->isp_2klogin = 1;
1094 FCPARAM(isp)->isp_sccfw = 1;
1095 FCPARAM(isp)->isp_tmode = 1;
1096 } else {
1097 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
1098 FCPARAM(isp)->isp_sccfw = 1;
1099 }
1100 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_2KLOGINS) {
1101 FCPARAM(isp)->isp_2klogin = 1;
1102 FCPARAM(isp)->isp_sccfw = 1;
1103 }
1104 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_TMODE) {
1105 FCPARAM(isp)->isp_tmode = 1;
1106 }
1107 }
1108 if (FCPARAM(isp)->isp_2klogin) {
1109 isp_prt(isp, ISP_LOGCONFIG, "2K Logins Supported");
1110 }
1111 }
1112
1113 if (isp->isp_romfw_rev[0] || isp->isp_romfw_rev[1] ||
1114 isp->isp_romfw_rev[2]) {
1115 isp_prt(isp, ISP_LOGCONFIG, "Last F/W revision was %d.%d.%d",
1116 isp->isp_romfw_rev[0], isp->isp_romfw_rev[1],
1117 isp->isp_romfw_rev[2]);
1118 }
1119
1120 if (!IS_24XX(isp)) {
1121 MEMZERO(&mbs, sizeof (mbs));
1122 mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
1123 mbs.logval = MBLOGALL;
1124 isp_mboxcmd(isp, &mbs);
1125 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1126 ISP_RESET0(isp);
1127 return;
1128 }
1129 if (isp->isp_maxcmds >= mbs.param[2]) {
1130 isp->isp_maxcmds = mbs.param[2];
1131 }
1132 }
1133 isp_prt(isp, ISP_LOGCONFIG,
1134 "%d max I/O command limit set", isp->isp_maxcmds);
1135 isp_fw_state(isp);
1136
1137 isp->isp_state = ISP_RESETSTATE;
1138
1139 /*
1140 * Okay- now that we have new firmware running, we now (re)set our
1141 * notion of how many luns we support. This is somewhat tricky because
1142 * if we haven't loaded firmware, we sometimes do not have an easy way
1143 * of knowing how many luns we support.
1144 *
1145 * Expanded lun firmware gives you 32 luns for SCSI cards and
1146 * 16384 luns for Fibre Channel cards.
1147 *
1148 * It turns out that even for QLogic 2100s with ROM 1.10 and above
1149 * we do get a firmware attributes word returned in mailbox register 6.
1150 *
1151 * Because the lun is in a different position in the Request Queue
1152 * Entry structure for Fibre Channel with expanded lun firmware, we
1153 * can only support one lun (lun zero) when we don't know what kind
1154 * of firmware we're running.
1155 */
1156 if (IS_SCSI(isp)) {
1157 if (dodnld) {
1158 if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
1159 isp->isp_maxluns = 32;
1160 } else {
1161 isp->isp_maxluns = 8;
1162 }
1163 } else {
1164 isp->isp_maxluns = 8;
1165 }
1166 } else {
1167 if (FCPARAM(isp)->isp_sccfw) {
1168 isp->isp_maxluns = 16384;
1169 } else {
1170 isp->isp_maxluns = 16;
1171 }
1172 }
1173 /*
1174 * Must do this first to get defaults established.
1175 */
1176 isp_setdfltparm(isp, 0);
1177 if (IS_DUALBUS(isp)) {
1178 isp_setdfltparm(isp, 1);
1179 }
1180
1181}
1182
1183/*
1184 * Initialize Parameters of Hardware to a known state.
1185 *
1186 * Locks are held before coming here.
1187 */
1188
1189void
1190isp_init(ispsoftc_t *isp)
1191{
1192 if (IS_FC(isp)) {
1193 /*
1194 * Do this *before* initializing the firmware.
1195 */
1196 ISP_MARK_PORTDB(isp, 0);
1197 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
1198 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
1199
1200 if (isp->isp_role != ISP_ROLE_NONE) {
1201 if (IS_24XX(isp)) {
1202 isp_fibre_init_2400(isp);
1203 } else {
1204 isp_fibre_init(isp);
1205 }
1206 }
1207 } else {
1208 isp_scsi_init(isp);
1209 }
1210}
1211
1212static void
1213isp_scsi_init(ispsoftc_t *isp)
1214{
1215 sdparam *sdp_chan0, *sdp_chan1;
1216 mbreg_t mbs;
1217
1218 sdp_chan0 = isp->isp_param;
1219 sdp_chan1 = sdp_chan0;
1220 if (IS_DUALBUS(isp)) {
1221 sdp_chan1++;
1222 }
1223
1224 /*
1225 * If we have no role (neither target nor initiator), return.
1226 */
1227 if (isp->isp_role == ISP_ROLE_NONE) {
1228 return;
1229 }
1230
1231 /* First do overall per-card settings. */
1232
1233 /*
1234 * If we have fast memory timing enabled, turn it on.
1235 */
1236 if (sdp_chan0->isp_fast_mttr) {
1237 ISP_WRITE(isp, RISC_MTR, 0x1313);
1238 }
1239
1240 /*
1241 * Set Retry Delay and Count.
1242 * You set both channels at the same time.
1243 */
1244 MEMZERO(&mbs, sizeof (mbs));
1245 mbs.param[0] = MBOX_SET_RETRY_COUNT;
1246 mbs.param[1] = sdp_chan0->isp_retry_count;
1247 mbs.param[2] = sdp_chan0->isp_retry_delay;
1248 mbs.param[6] = sdp_chan1->isp_retry_count;
1249 mbs.param[7] = sdp_chan1->isp_retry_delay;
1250 mbs.logval = MBLOGALL;
1251 isp_mboxcmd(isp, &mbs);
1252 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1253 return;
1254 }
1255
1256 /*
1257 * Set ASYNC DATA SETUP time. This is very important.
1258 */
1259 MEMZERO(&mbs, sizeof (mbs));
1260 mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
1261 mbs.param[1] = sdp_chan0->isp_async_data_setup;
1262 mbs.param[2] = sdp_chan1->isp_async_data_setup;
1263 mbs.logval = MBLOGALL;
1264 isp_mboxcmd(isp, &mbs);
1265 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1266 return;
1267 }
1268
1269 /*
1270 * Set ACTIVE Negation State.
1271 */
1272 MEMZERO(&mbs, sizeof (mbs));
1273 mbs.param[0] = MBOX_SET_ACT_NEG_STATE;
1274 mbs.param[1] =
1275 (sdp_chan0->isp_req_ack_active_neg << 4) |
1276 (sdp_chan0->isp_data_line_active_neg << 5);
1277 mbs.param[2] =
1278 (sdp_chan1->isp_req_ack_active_neg << 4) |
1279 (sdp_chan1->isp_data_line_active_neg << 5);
1280 mbs.logval = MBLOGNONE;
1281 isp_mboxcmd(isp, &mbs);
1282 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1283 isp_prt(isp, ISP_LOGERR,
1284 "failed to set active negation state (%d,%d), (%d,%d)",
1285 sdp_chan0->isp_req_ack_active_neg,
1286 sdp_chan0->isp_data_line_active_neg,
1287 sdp_chan1->isp_req_ack_active_neg,
1288 sdp_chan1->isp_data_line_active_neg);
1289 /*
1290 * But don't return.
1291 */
1292 }
1293
1294 /*
1295 * Set the Tag Aging limit
1296 */
1297 MEMZERO(&mbs, sizeof (mbs));
1298 mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
1299 mbs.param[1] = sdp_chan0->isp_tag_aging;
1300 mbs.param[2] = sdp_chan1->isp_tag_aging;
1301 mbs.logval = MBLOGALL;
1302 isp_mboxcmd(isp, &mbs);
1303 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1304 isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
1305 sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
1306 return;
1307 }
1308
1309 /*
1310 * Set selection timeout.
1311 */
1312 MEMZERO(&mbs, sizeof (mbs));
1313 mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
1314 mbs.param[1] = sdp_chan0->isp_selection_timeout;
1315 mbs.param[2] = sdp_chan1->isp_selection_timeout;
1316 mbs.logval = MBLOGALL;
1317 isp_mboxcmd(isp, &mbs);
1318 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1319 return;
1320 }
1321
1322 /* now do per-channel settings */
1323 isp_scsi_channel_init(isp, 0);
1324 if (IS_DUALBUS(isp))
1325 isp_scsi_channel_init(isp, 1);
1326
1327 /*
1328 * Now enable request/response queues
1329 */
1330
1331 if (IS_ULTRA2(isp) || IS_1240(isp)) {
1332 MEMZERO(&mbs, sizeof (mbs));
1333 mbs.param[0] = MBOX_INIT_RES_QUEUE_A64;
1334 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1335 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1336 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1337 mbs.param[4] = 0;
1338 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1339 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1340 mbs.logval = MBLOGALL;
1341 isp_mboxcmd(isp, &mbs);
1342 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1343 return;
1344 }
1345 isp->isp_residx = mbs.param[5];
1346
1347 MEMZERO(&mbs, sizeof (mbs));
1348 mbs.param[0] = MBOX_INIT_REQ_QUEUE_A64;
1349 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1350 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1351 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1352 mbs.param[5] = 0;
1353 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1354 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1355 mbs.logval = MBLOGALL;
1356 isp_mboxcmd(isp, &mbs);
1357 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1358 return;
1359 }
1360 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1361 } else {
1362 MEMZERO(&mbs, sizeof (mbs));
1363 mbs.param[0] = MBOX_INIT_RES_QUEUE;
1364 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1365 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1366 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1367 mbs.param[4] = 0;
1368 mbs.logval = MBLOGALL;
1369 isp_mboxcmd(isp, &mbs);
1370 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1371 return;
1372 }
1373 isp->isp_residx = mbs.param[5];
1374
1375 MEMZERO(&mbs, sizeof (mbs));
1376 mbs.param[0] = MBOX_INIT_REQ_QUEUE;
1377 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1378 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1379 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1380 mbs.param[5] = 0;
1381 mbs.logval = MBLOGALL;
1382 isp_mboxcmd(isp, &mbs);
1383 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1384 return;
1385 }
1386 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1387 }
1388
1389 /*
1390 * Turn on Fast Posting, LVD transitions
1391 *
1392 * Ultra2 F/W always has had fast posting (and LVD transitions)
1393 *
1394 * Ultra and older (i.e., SBus) cards may not. It's just safer
1395 * to assume not for them.
1396 */
1397
1398 MEMZERO(&mbs, sizeof (mbs));
1399 mbs.param[0] = MBOX_SET_FW_FEATURES;
1400 mbs.param[1] = 0;
1401 if (IS_ULTRA2(isp))
1402 mbs.param[1] |= FW_FEATURE_LVD_NOTIFY;
1403#ifndef ISP_NO_RIO
1404 if (IS_ULTRA2(isp) || IS_1240(isp))
1405 mbs.param[1] |= FW_FEATURE_RIO_16BIT;
1406#else
1407 if (IS_ULTRA2(isp) || IS_1240(isp))
1408 mbs.param[1] |= FW_FEATURE_FAST_POST;
1409#endif
1410 if (mbs.param[1] != 0) {
1411 uint16_t sfeat = mbs.param[1];
1412 mbs.logval = MBLOGALL;
1413 isp_mboxcmd(isp, &mbs);
1414 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1415 isp_prt(isp, ISP_LOGINFO,
1416 "Enabled FW features (0x%x)", sfeat);
1417 }
1418 }
1419
1420 /*
1421 * Let the outer layers decide whether to issue a SCSI bus reset.
1422 */
1423 isp->isp_state = ISP_INITSTATE;
1424}
1425
1426static void
1427isp_scsi_channel_init(ispsoftc_t *isp, int channel)
1428{
1429 sdparam *sdp;
1430 mbreg_t mbs;
1431 int tgt;
1432
1433 sdp = isp->isp_param;
1434 sdp += channel;
1435
1436 /*
1437 * Set (possibly new) Initiator ID.
1438 */
1439 MEMZERO(&mbs, sizeof (mbs));
1440 mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
1441 mbs.param[1] = (channel << 7) | sdp->isp_initiator_id;
1442 mbs.logval = MBLOGALL;
1443 isp_mboxcmd(isp, &mbs);
1444 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1445 return;
1446 }
1447 isp_prt(isp, ISP_LOGINFO, "Initiator ID is %d on Channel %d",
1448 sdp->isp_initiator_id, channel);
1449
1450
1451 /*
1452 * Set current per-target parameters to an initial safe minimum.
1453 */
1454 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1455 int lun;
1456 uint16_t sdf;
1457
1458 if (sdp->isp_devparam[tgt].dev_enable == 0) {
1459 continue;
1460 }
1461#ifndef ISP_TARGET_MODE
1462 sdf = sdp->isp_devparam[tgt].goal_flags;
1463 sdf &= DPARM_SAFE_DFLT;
1464 /*
1465 * It is not quite clear when this changed over so that
1466 * we could force narrow and async for 1000/1020 cards,
1467 * but assume that this is only the case for loaded
1468 * firmware.
1469 */
1470 if (isp->isp_loaded_fw) {
1471 sdf |= DPARM_NARROW | DPARM_ASYNC;
1472 }
1473#else
1474 /*
1475 * The !$*!)$!$)* f/w uses the same index into some
1476 * internal table to decide how to respond to negotiations,
1477 * so if we've said "let's be safe" for ID X, and ID X
1478 * selects *us*, the negotiations will back to 'safe'
1479 * (as in narrow/async). What the f/w *should* do is
1480 * use the initiator id settings to decide how to respond.
1481 */
1482 sdp->isp_devparam[tgt].goal_flags = sdf = DPARM_DEFAULT;
1483#endif
1484 MEMZERO(&mbs, sizeof (mbs));
1485 mbs.param[0] = MBOX_SET_TARGET_PARAMS;
1486 mbs.param[1] = (channel << 15) | (tgt << 8);
1487 mbs.param[2] = sdf;
1488 if ((sdf & DPARM_SYNC) == 0) {
1489 mbs.param[3] = 0;
1490 } else {
1491 mbs.param[3] =
1492 (sdp->isp_devparam[tgt].goal_offset << 8) |
1493 (sdp->isp_devparam[tgt].goal_period);
1494 }
1495 isp_prt(isp, ISP_LOGDEBUG0,
1496 "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
1497 channel, tgt, mbs.param[2], mbs.param[3] >> 8,
1498 mbs.param[3] & 0xff);
1499 mbs.logval = MBLOGNONE;
1500 isp_mboxcmd(isp, &mbs);
1501 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1502 sdf = DPARM_SAFE_DFLT;
1503 MEMZERO(&mbs, sizeof (mbs));
1504 mbs.param[0] = MBOX_SET_TARGET_PARAMS;
1505 mbs.param[1] = (tgt << 8) | (channel << 15);
1506 mbs.param[2] = sdf;
1507 mbs.param[3] = 0;
1508 mbs.logval = MBLOGALL;
1509 isp_mboxcmd(isp, &mbs);
1510 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1511 continue;
1512 }
1513 }
1514
1515 /*
1516 * We don't update any information directly from the f/w
1517 * because we need to run at least one command to cause a
1518 * new state to be latched up. So, we just assume that we
1519 * converge to the values we just had set.
1520 *
1521 * Ensure that we don't believe tagged queuing is enabled yet.
1522 * It turns out that sometimes the ISP just ignores our
1523 * attempts to set parameters for devices that it hasn't
1524 * seen yet.
1525 */
1526 sdp->isp_devparam[tgt].actv_flags = sdf & ~DPARM_TQING;
1527 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1528 MEMZERO(&mbs, sizeof (mbs));
1529 mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
1530 mbs.param[1] = (channel << 15) | (tgt << 8) | lun;
1531 mbs.param[2] = sdp->isp_max_queue_depth;
1532 mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
1533 mbs.logval = MBLOGALL;
1534 isp_mboxcmd(isp, &mbs);
1535 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1536 break;
1537 }
1538 }
1539 }
1540 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1541 if (sdp->isp_devparam[tgt].dev_refresh) {
1542 isp->isp_sendmarker |= (1 << channel);
1543 isp->isp_update |= (1 << channel);
1544 break;
1545 }
1546 }
1547}
1548
1549/*
1550 * Fibre Channel specific initialization.
1551 */
1552static void
1553isp_fibre_init(ispsoftc_t *isp)
1554{
1555 fcparam *fcp;
1556 isp_icb_t local, *icbp = &local;
1557 mbreg_t mbs;
|
| 1558 int ownloopid;
|
1558 uint64_t nwwn, pwwn;
1559
1560 fcp = isp->isp_param;
1561
1562 MEMZERO(icbp, sizeof (*icbp));
1563 icbp->icb_version = ICB_VERSION1;
1564 icbp->icb_fwoptions = fcp->isp_fwoptions;
1565
1566 /*
1567 * Firmware Options are either retrieved from NVRAM or
1568 * are patched elsewhere. We check them for sanity here
1569 * and make changes based on board revision, but otherwise
1570 * let others decide policy.
1571 */
1572
1573 /*
1574 * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
1575 */
1576 if (IS_2100(isp) && isp->isp_revision < 5) {
1577 icbp->icb_fwoptions &= ~ICBOPT_FAIRNESS;
1578 }
1579
1580 /*
1581 * We have to use FULL LOGIN even though it resets the loop too much
1582 * because otherwise port database entries don't get updated after
1583 * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
1584 */
1585 if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1586 icbp->icb_fwoptions |= ICBOPT_FULL_LOGIN;
1587 }
1588
1589 /*
1590 * Insist on Port Database Update Async notifications
1591 */
1592 icbp->icb_fwoptions |= ICBOPT_PDBCHANGE_AE;
1593
1594 /*
1595 * Make sure that target role reflects into fwoptions.
1596 */
1597 if (isp->isp_role & ISP_ROLE_TARGET) {
1598 icbp->icb_fwoptions |= ICBOPT_TGT_ENABLE;
1599 } else {
1600 icbp->icb_fwoptions &= ~ICBOPT_TGT_ENABLE;
1601 }
1602
1603 if (isp->isp_role & ISP_ROLE_INITIATOR) {
1604 icbp->icb_fwoptions &= ~ICBOPT_INI_DISABLE;
1605 } else {
1606 icbp->icb_fwoptions |= ICBOPT_INI_DISABLE;
1607 }
1608
1609 icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
1610 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
1611 icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1612 isp_prt(isp, ISP_LOGERR,
1613 "bad frame length (%d) from NVRAM- using %d",
1614 fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
1615 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1616 }
1617 icbp->icb_maxalloc = fcp->isp_maxalloc;
1618 if (icbp->icb_maxalloc < 1) {
1619 isp_prt(isp, ISP_LOGERR,
1620 "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1621 icbp->icb_maxalloc = 16;
1622 }
1623 icbp->icb_execthrottle = fcp->isp_execthrottle;
1624 if (icbp->icb_execthrottle < 1) {
1625 isp_prt(isp, ISP_LOGERR,
1626 "bad execution throttle of %d- using 16",
1627 fcp->isp_execthrottle);
1628 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1629 }
1630 icbp->icb_retry_delay = fcp->isp_retry_delay;
1631 icbp->icb_retry_count = fcp->isp_retry_count;
1632 icbp->icb_hardaddr = fcp->isp_loopid;
| 1559 uint64_t nwwn, pwwn;
1560
1561 fcp = isp->isp_param;
1562
1563 MEMZERO(icbp, sizeof (*icbp));
1564 icbp->icb_version = ICB_VERSION1;
1565 icbp->icb_fwoptions = fcp->isp_fwoptions;
1566
1567 /*
1568 * Firmware Options are either retrieved from NVRAM or
1569 * are patched elsewhere. We check them for sanity here
1570 * and make changes based on board revision, but otherwise
1571 * let others decide policy.
1572 */
1573
1574 /*
1575 * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
1576 */
1577 if (IS_2100(isp) && isp->isp_revision < 5) {
1578 icbp->icb_fwoptions &= ~ICBOPT_FAIRNESS;
1579 }
1580
1581 /*
1582 * We have to use FULL LOGIN even though it resets the loop too much
1583 * because otherwise port database entries don't get updated after
1584 * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
1585 */
1586 if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1587 icbp->icb_fwoptions |= ICBOPT_FULL_LOGIN;
1588 }
1589
1590 /*
1591 * Insist on Port Database Update Async notifications
1592 */
1593 icbp->icb_fwoptions |= ICBOPT_PDBCHANGE_AE;
1594
1595 /*
1596 * Make sure that target role reflects into fwoptions.
1597 */
1598 if (isp->isp_role & ISP_ROLE_TARGET) {
1599 icbp->icb_fwoptions |= ICBOPT_TGT_ENABLE;
1600 } else {
1601 icbp->icb_fwoptions &= ~ICBOPT_TGT_ENABLE;
1602 }
1603
1604 if (isp->isp_role & ISP_ROLE_INITIATOR) {
1605 icbp->icb_fwoptions &= ~ICBOPT_INI_DISABLE;
1606 } else {
1607 icbp->icb_fwoptions |= ICBOPT_INI_DISABLE;
1608 }
1609
1610 icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
1611 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
1612 icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1613 isp_prt(isp, ISP_LOGERR,
1614 "bad frame length (%d) from NVRAM- using %d",
1615 fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
1616 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1617 }
1618 icbp->icb_maxalloc = fcp->isp_maxalloc;
1619 if (icbp->icb_maxalloc < 1) {
1620 isp_prt(isp, ISP_LOGERR,
1621 "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1622 icbp->icb_maxalloc = 16;
1623 }
1624 icbp->icb_execthrottle = fcp->isp_execthrottle;
1625 if (icbp->icb_execthrottle < 1) {
1626 isp_prt(isp, ISP_LOGERR,
1627 "bad execution throttle of %d- using 16",
1628 fcp->isp_execthrottle);
1629 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1630 }
1631 icbp->icb_retry_delay = fcp->isp_retry_delay;
1632 icbp->icb_retry_count = fcp->isp_retry_count;
1633 icbp->icb_hardaddr = fcp->isp_loopid;
|
| 1634 ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
|
1633 if (icbp->icb_hardaddr > 125) {
| 1635 if (icbp->icb_hardaddr > 125) {
|
1634 /*
1635 * We end up with these Loop IDs for F-Port topologies
1636 */
1637 if (icbp->icb_hardaddr != 0xff &&
1638 icbp->icb_hardaddr != 0x800 &&
1639 icbp->icb_hardaddr != 0xffff) {
1640 isp_prt(isp, ISP_LOGERR,
1641 "bad hard address %u- resetting to zero",
1642 icbp->icb_hardaddr);
1643 icbp->icb_hardaddr = 0;
1644 }
| 1636 icbp->icb_hardaddr = 0;
1637 ownloopid = 0;
|
1645 }
1646
1647 /*
1648 * Our life seems so much better with 2200s and later with
1649 * the latest f/w if we set Hard Address.
1650 */
| 1638 }
1639
1640 /*
1641 * Our life seems so much better with 2200s and later with
1642 * the latest f/w if we set Hard Address.
1643 */
|
1651 if (ISP_FW_NEWER_THAN(isp, 2, 2, 5)) {
| 1644 if (ownloopid || ISP_FW_NEWER_THAN(isp, 2, 2, 5)) {
|
1652 icbp->icb_fwoptions |= ICBOPT_HARD_ADDRESS;
1653 }
1654
1655 /*
1656 * Right now we just set extended options to prefer point-to-point
1657 * over loop based upon some soft config options.
1658 *
1659 * NB: for the 2300, ICBOPT_EXTENDED is required.
1660 */
1661 if (IS_2200(isp) || IS_23XX(isp)) {
1662 icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1663 /*
1664 * Prefer or force Point-To-Point instead Loop?
1665 */
1666 switch(isp->isp_confopts & ISP_CFG_PORT_PREF) {
1667 case ISP_CFG_NPORT:
1668 icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
1669 break;
1670 case ISP_CFG_NPORT_ONLY:
1671 icbp->icb_xfwoptions |= ICBXOPT_PTP_ONLY;
1672 break;
1673 case ISP_CFG_LPORT_ONLY:
1674 icbp->icb_xfwoptions |= ICBXOPT_LOOP_ONLY;
1675 break;
1676 default:
1677 icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1678 break;
1679 }
1680 if (IS_2200(isp)) {
1681 if (ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1682 icbp->icb_xfwoptions |= ICBXOPT_RIO_16BIT;
1683 icbp->icb_racctimer = 4;
1684 icbp->icb_idelaytimer = 8;
1685 }
1686 icbp->icb_fwoptions |= ICBOPT_FAST_POST;
1687 } else {
1688 /*
1689 * QLogic recommends that FAST Posting be turned
1690 * off for 23XX cards and instead allow the HBA
1691 * to write response queue entries and interrupt
1692 * after a delay (ZIO).
1693 */
1694 icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1695 if ((fcp->isp_xfwoptions & ICBXOPT_TIMER_MASK) ==
1696 ICBXOPT_ZIO) {
1697 icbp->icb_xfwoptions |= ICBXOPT_ZIO;
1698 icbp->icb_idelaytimer = 10;
1699 }
1700 if (isp->isp_confopts & ISP_CFG_ONEGB) {
1701 icbp->icb_zfwoptions |= ICBZOPT_RATE_ONEGB;
1702 } else if (isp->isp_confopts & ISP_CFG_TWOGB) {
1703 icbp->icb_zfwoptions |= ICBZOPT_RATE_TWOGB;
1704 } else {
1705 icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO;
1706 }
1707 if (fcp->isp_zfwoptions & ICBZOPT_50_OHM) {
1708 icbp->icb_zfwoptions |= ICBZOPT_50_OHM;
1709 }
1710 }
1711 }
1712
1713
1714 /*
1715 * For 22XX > 2.1.26 && 23XX, set some options.
1716 * XXX: Probably okay for newer 2100 f/w too.
1717 */
1718 if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1719 /*
1720 * Turn on LIP F8 async event (1)
1721 * Turn on generate AE 8013 on all LIP Resets (2)
1722 * Disable LIP F7 switching (8)
1723 */
1724 MEMZERO(&mbs, sizeof (mbs));
1725 mbs.param[0] = MBOX_SET_FIRMWARE_OPTIONS;
1726 mbs.param[1] = 0xb;
1727 mbs.param[2] = 0;
1728 mbs.param[3] = 0;
1729 mbs.logval = MBLOGALL;
1730 isp_mboxcmd(isp, &mbs);
1731 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1732 return;
1733 }
1734 }
1735 icbp->icb_logintime = ICB_LOGIN_TOV;
1736 icbp->icb_lunetimeout = ICB_LUN_ENABLE_TOV;
1737
1738 nwwn = ISP_NODEWWN(isp);
1739 pwwn = ISP_PORTWWN(isp);
1740 if (nwwn && pwwn) {
1741 icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
1742 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn);
1743 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1744 isp_prt(isp, ISP_LOGDEBUG1,
1745 "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1746 ((uint32_t) (nwwn >> 32)),
1747 ((uint32_t) (nwwn & 0xffffffff)),
1748 ((uint32_t) (pwwn >> 32)),
1749 ((uint32_t) (pwwn & 0xffffffff)));
1750 } else if (pwwn) {
1751 icbp->icb_fwoptions &= ~ICBOPT_BOTH_WWNS;
1752 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1753 isp_prt(isp, ISP_LOGDEBUG1,
1754 "Setting ICB Port 0x%08x%08x",
1755 ((uint32_t) (pwwn >> 32)),
1756 ((uint32_t) (pwwn & 0xffffffff)));
1757 } else {
1758 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1759 return;
1760 }
1761 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1762 if (icbp->icb_rqstqlen < 1) {
1763 isp_prt(isp, ISP_LOGERR, "bad request queue length");
1764 }
1765 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1766 if (icbp->icb_rsltqlen < 1) {
1767 isp_prt(isp, ISP_LOGERR, "bad result queue length");
1768 }
1769 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1770 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1771 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1772 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1773 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1774 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1775 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1776 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1777
1778 isp_prt(isp, ISP_LOGDEBUG0,
1779 "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
1780 icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions);
1781
1782 FC_SCRATCH_ACQUIRE(isp);
1783 isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
1784
1785 /*
1786 * Init the firmware
1787 */
1788 MEMZERO(&mbs, sizeof (mbs));
1789 mbs.param[0] = MBOX_INIT_FIRMWARE;
1790 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1791 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1792 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1793 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1794 mbs.logval = MBLOGALL;
1795 mbs.timeout = 30 * 1000000;
1796 isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %p (%08x%08x)",
1797 fcp->isp_scratch, (uint32_t) ((uint64_t)fcp->isp_scdma >> 32),
1798 (uint32_t) fcp->isp_scdma);
1799 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp));
1800 isp_mboxcmd(isp, &mbs);
1801 FC_SCRATCH_RELEASE(isp);
1802 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
| 1645 icbp->icb_fwoptions |= ICBOPT_HARD_ADDRESS;
1646 }
1647
1648 /*
1649 * Right now we just set extended options to prefer point-to-point
1650 * over loop based upon some soft config options.
1651 *
1652 * NB: for the 2300, ICBOPT_EXTENDED is required.
1653 */
1654 if (IS_2200(isp) || IS_23XX(isp)) {
1655 icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1656 /*
1657 * Prefer or force Point-To-Point instead Loop?
1658 */
1659 switch(isp->isp_confopts & ISP_CFG_PORT_PREF) {
1660 case ISP_CFG_NPORT:
1661 icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
1662 break;
1663 case ISP_CFG_NPORT_ONLY:
1664 icbp->icb_xfwoptions |= ICBXOPT_PTP_ONLY;
1665 break;
1666 case ISP_CFG_LPORT_ONLY:
1667 icbp->icb_xfwoptions |= ICBXOPT_LOOP_ONLY;
1668 break;
1669 default:
1670 icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1671 break;
1672 }
1673 if (IS_2200(isp)) {
1674 if (ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1675 icbp->icb_xfwoptions |= ICBXOPT_RIO_16BIT;
1676 icbp->icb_racctimer = 4;
1677 icbp->icb_idelaytimer = 8;
1678 }
1679 icbp->icb_fwoptions |= ICBOPT_FAST_POST;
1680 } else {
1681 /*
1682 * QLogic recommends that FAST Posting be turned
1683 * off for 23XX cards and instead allow the HBA
1684 * to write response queue entries and interrupt
1685 * after a delay (ZIO).
1686 */
1687 icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1688 if ((fcp->isp_xfwoptions & ICBXOPT_TIMER_MASK) ==
1689 ICBXOPT_ZIO) {
1690 icbp->icb_xfwoptions |= ICBXOPT_ZIO;
1691 icbp->icb_idelaytimer = 10;
1692 }
1693 if (isp->isp_confopts & ISP_CFG_ONEGB) {
1694 icbp->icb_zfwoptions |= ICBZOPT_RATE_ONEGB;
1695 } else if (isp->isp_confopts & ISP_CFG_TWOGB) {
1696 icbp->icb_zfwoptions |= ICBZOPT_RATE_TWOGB;
1697 } else {
1698 icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO;
1699 }
1700 if (fcp->isp_zfwoptions & ICBZOPT_50_OHM) {
1701 icbp->icb_zfwoptions |= ICBZOPT_50_OHM;
1702 }
1703 }
1704 }
1705
1706
1707 /*
1708 * For 22XX > 2.1.26 && 23XX, set some options.
1709 * XXX: Probably okay for newer 2100 f/w too.
1710 */
1711 if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1712 /*
1713 * Turn on LIP F8 async event (1)
1714 * Turn on generate AE 8013 on all LIP Resets (2)
1715 * Disable LIP F7 switching (8)
1716 */
1717 MEMZERO(&mbs, sizeof (mbs));
1718 mbs.param[0] = MBOX_SET_FIRMWARE_OPTIONS;
1719 mbs.param[1] = 0xb;
1720 mbs.param[2] = 0;
1721 mbs.param[3] = 0;
1722 mbs.logval = MBLOGALL;
1723 isp_mboxcmd(isp, &mbs);
1724 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1725 return;
1726 }
1727 }
1728 icbp->icb_logintime = ICB_LOGIN_TOV;
1729 icbp->icb_lunetimeout = ICB_LUN_ENABLE_TOV;
1730
1731 nwwn = ISP_NODEWWN(isp);
1732 pwwn = ISP_PORTWWN(isp);
1733 if (nwwn && pwwn) {
1734 icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
1735 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn);
1736 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1737 isp_prt(isp, ISP_LOGDEBUG1,
1738 "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1739 ((uint32_t) (nwwn >> 32)),
1740 ((uint32_t) (nwwn & 0xffffffff)),
1741 ((uint32_t) (pwwn >> 32)),
1742 ((uint32_t) (pwwn & 0xffffffff)));
1743 } else if (pwwn) {
1744 icbp->icb_fwoptions &= ~ICBOPT_BOTH_WWNS;
1745 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1746 isp_prt(isp, ISP_LOGDEBUG1,
1747 "Setting ICB Port 0x%08x%08x",
1748 ((uint32_t) (pwwn >> 32)),
1749 ((uint32_t) (pwwn & 0xffffffff)));
1750 } else {
1751 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1752 return;
1753 }
1754 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1755 if (icbp->icb_rqstqlen < 1) {
1756 isp_prt(isp, ISP_LOGERR, "bad request queue length");
1757 }
1758 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1759 if (icbp->icb_rsltqlen < 1) {
1760 isp_prt(isp, ISP_LOGERR, "bad result queue length");
1761 }
1762 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1763 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1764 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1765 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1766 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1767 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1768 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1769 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1770
1771 isp_prt(isp, ISP_LOGDEBUG0,
1772 "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
1773 icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions);
1774
1775 FC_SCRATCH_ACQUIRE(isp);
1776 isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
1777
1778 /*
1779 * Init the firmware
1780 */
1781 MEMZERO(&mbs, sizeof (mbs));
1782 mbs.param[0] = MBOX_INIT_FIRMWARE;
1783 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1784 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1785 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1786 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1787 mbs.logval = MBLOGALL;
1788 mbs.timeout = 30 * 1000000;
1789 isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %p (%08x%08x)",
1790 fcp->isp_scratch, (uint32_t) ((uint64_t)fcp->isp_scdma >> 32),
1791 (uint32_t) fcp->isp_scdma);
1792 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp));
1793 isp_mboxcmd(isp, &mbs);
1794 FC_SCRATCH_RELEASE(isp);
1795 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
|
| 1796 isp_print_bytes(isp, "isp_fibre_init", sizeof (*icbp), icbp);
|
1803 return;
1804 }
1805 isp->isp_reqidx = 0;
1806 isp->isp_reqodx = 0;
1807 isp->isp_residx = 0;
1808
1809 /*
1810 * Whatever happens, we're now committed to being here.
1811 */
1812 isp->isp_state = ISP_INITSTATE;
1813}
1814
1815static void
1816isp_fibre_init_2400(ispsoftc_t *isp)
1817{
1818 fcparam *fcp;
1819 isp_icb_2400_t local, *icbp = &local;
1820 mbreg_t mbs;
| 1797 return;
1798 }
1799 isp->isp_reqidx = 0;
1800 isp->isp_reqodx = 0;
1801 isp->isp_residx = 0;
1802
1803 /*
1804 * Whatever happens, we're now committed to being here.
1805 */
1806 isp->isp_state = ISP_INITSTATE;
1807}
1808
1809static void
1810isp_fibre_init_2400(ispsoftc_t *isp)
1811{
1812 fcparam *fcp;
1813 isp_icb_2400_t local, *icbp = &local;
1814 mbreg_t mbs;
|
| 1815 int ownloopid;
|
1821 uint64_t nwwn, pwwn;
1822
1823 fcp = isp->isp_param;
1824
1825 /*
1826 * Turn on LIP F8 async event (1)
1827 */
1828 MEMZERO(&mbs, sizeof (mbs));
1829 mbs.param[0] = MBOX_SET_FIRMWARE_OPTIONS;
1830 mbs.param[1] = 1;
1831 mbs.logval = MBLOGALL;
1832 isp_mboxcmd(isp, &mbs);
1833 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1834 return;
1835 }
1836
1837 /*
1838 * XXX: This should be applied to icb- not fwoptions
1839 */
1840 if (isp->isp_role & ISP_ROLE_TARGET) {
1841 fcp->isp_fwoptions |= ICB2400_OPT1_TGT_ENABLE;
1842 } else {
1843 fcp->isp_fwoptions &= ~ICB2400_OPT1_TGT_ENABLE;
1844 }
1845
1846 if (isp->isp_role & ISP_ROLE_INITIATOR) {
1847 fcp->isp_fwoptions &= ~ICB2400_OPT1_INI_DISABLE;
1848 } else {
1849 fcp->isp_fwoptions |= ICB2400_OPT1_INI_DISABLE;
1850 }
1851
1852 MEMZERO(icbp, sizeof (*icbp));
1853 icbp->icb_version = ICB_VERSION1;
1854 icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
1855 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
1856 icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1857 isp_prt(isp, ISP_LOGERR,
1858 "bad frame length (%d) from NVRAM- using %d",
1859 fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
1860 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1861 }
1862
1863 icbp->icb_execthrottle = fcp->isp_execthrottle;
1864 if (icbp->icb_execthrottle < 1) {
1865 isp_prt(isp, ISP_LOGERR,
1866 "bad execution throttle of %d- using 16",
1867 fcp->isp_execthrottle);
1868 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1869 }
1870
1871 if (isp->isp_role & ISP_ROLE_TARGET) {
1872 /*
1873 * Get current resource count
1874 */
1875 MEMZERO(&mbs, sizeof (mbs));
1876 mbs.param[0] = MBOX_GET_RESOURCE_COUNT;
1877 mbs.obits = 0x4cf;
1878 mbs.logval = MBLOGALL;
1879 isp_mboxcmd(isp, &mbs);
1880 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1881 return;
1882 }
1883 icbp->icb_xchgcnt = mbs.param[3];
1884 }
1885
1886 icbp->icb_fwoptions1 = fcp->isp_fwoptions;
1887
1888 icbp->icb_hardaddr = fcp->isp_loopid;
| 1816 uint64_t nwwn, pwwn;
1817
1818 fcp = isp->isp_param;
1819
1820 /*
1821 * Turn on LIP F8 async event (1)
1822 */
1823 MEMZERO(&mbs, sizeof (mbs));
1824 mbs.param[0] = MBOX_SET_FIRMWARE_OPTIONS;
1825 mbs.param[1] = 1;
1826 mbs.logval = MBLOGALL;
1827 isp_mboxcmd(isp, &mbs);
1828 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1829 return;
1830 }
1831
1832 /*
1833 * XXX: This should be applied to icb- not fwoptions
1834 */
1835 if (isp->isp_role & ISP_ROLE_TARGET) {
1836 fcp->isp_fwoptions |= ICB2400_OPT1_TGT_ENABLE;
1837 } else {
1838 fcp->isp_fwoptions &= ~ICB2400_OPT1_TGT_ENABLE;
1839 }
1840
1841 if (isp->isp_role & ISP_ROLE_INITIATOR) {
1842 fcp->isp_fwoptions &= ~ICB2400_OPT1_INI_DISABLE;
1843 } else {
1844 fcp->isp_fwoptions |= ICB2400_OPT1_INI_DISABLE;
1845 }
1846
1847 MEMZERO(icbp, sizeof (*icbp));
1848 icbp->icb_version = ICB_VERSION1;
1849 icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
1850 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
1851 icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1852 isp_prt(isp, ISP_LOGERR,
1853 "bad frame length (%d) from NVRAM- using %d",
1854 fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
1855 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1856 }
1857
1858 icbp->icb_execthrottle = fcp->isp_execthrottle;
1859 if (icbp->icb_execthrottle < 1) {
1860 isp_prt(isp, ISP_LOGERR,
1861 "bad execution throttle of %d- using 16",
1862 fcp->isp_execthrottle);
1863 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1864 }
1865
1866 if (isp->isp_role & ISP_ROLE_TARGET) {
1867 /*
1868 * Get current resource count
1869 */
1870 MEMZERO(&mbs, sizeof (mbs));
1871 mbs.param[0] = MBOX_GET_RESOURCE_COUNT;
1872 mbs.obits = 0x4cf;
1873 mbs.logval = MBLOGALL;
1874 isp_mboxcmd(isp, &mbs);
1875 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1876 return;
1877 }
1878 icbp->icb_xchgcnt = mbs.param[3];
1879 }
1880
1881 icbp->icb_fwoptions1 = fcp->isp_fwoptions;
1882
1883 icbp->icb_hardaddr = fcp->isp_loopid;
|
| 1884 ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
|
1889 if (icbp->icb_hardaddr > 125) {
| 1885 if (icbp->icb_hardaddr > 125) {
|
1890 /*
1891 * We end up with these Loop IDs for F-Port topologies
1892 */
1893 if (icbp->icb_hardaddr != 0xff &&
1894 icbp->icb_hardaddr != 0x800 &&
1895 icbp->icb_hardaddr != 0xffff) {
1896 isp_prt(isp, ISP_LOGERR,
1897 "bad hard address %u- resetting to zero",
1898 icbp->icb_hardaddr);
1899 icbp->icb_hardaddr = 0;
1900 }
| 1886 icbp->icb_hardaddr = 0;
1887 ownloopid = 0;
|
1901 }
| 1888 }
|
1902
1903 if (isp->isp_confopts & ISP_CFG_OWNLOOPID) {
| 1889 if (ownloopid) {
|
1904 icbp->icb_fwoptions1 |= ICB2400_OPT1_HARD_ADDRESS;
1905 }
1906
1907 icbp->icb_fwoptions2 = fcp->isp_xfwoptions;
1908 switch(isp->isp_confopts & ISP_CFG_PORT_PREF) {
1909 case ISP_CFG_NPORT:
1910 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1911 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_2_LOOP;
1912 break;
1913 case ISP_CFG_NPORT_ONLY:
1914 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1915 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_ONLY;
1916 break;
1917 case ISP_CFG_LPORT_ONLY:
1918 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1919 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_ONLY;
1920 break;
1921 default:
1922 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1923 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
1924 break;
1925 }
1926
1927 switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK) {
1928 case ICB2400_OPT2_ZIO:
1929 case ICB2400_OPT2_ZIO1:
1930 icbp->icb_idelaytimer = 0;
1931 break;
1932 case 0:
1933 break;
1934 default:
1935 isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field",
1936 icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
1937 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TIMER_MASK;
1938 break;
1939 }
1940
1941 icbp->icb_fwoptions3 = fcp->isp_zfwoptions;
1942 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_AUTO;
1943 if (isp->isp_confopts & ISP_CFG_ONEGB) {
1944 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_ONEGB;
1945 } else if (isp->isp_confopts & ISP_CFG_TWOGB) {
1946 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_TWOGB;
1947 } else if (isp->isp_confopts & ISP_CFG_FOURGB) {
1948 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_FOURGB;
1949 } else {
1950 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_AUTO;
1951 }
1952
1953 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
1954 icbp->icb_fwoptions3 |= ICB2400_OPT3_SOFTID;
1955 }
1956 icbp->icb_logintime = ICB_LOGIN_TOV;
1957
1958 nwwn = ISP_NODEWWN(isp);
1959 pwwn = ISP_PORTWWN(isp);
1960
1961 if (nwwn && pwwn) {
1962 icbp->icb_fwoptions1 |= ICB2400_OPT1_BOTH_WWNS;
1963 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn);
1964 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1965 isp_prt(isp, ISP_LOGDEBUG1,
1966 "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1967 ((uint32_t) (nwwn >> 32)),
1968 ((uint32_t) (nwwn & 0xffffffff)),
1969 ((uint32_t) (pwwn >> 32)),
1970 ((uint32_t) (pwwn & 0xffffffff)));
1971 } else if (pwwn) {
1972 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_BOTH_WWNS;
1973 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1974 isp_prt(isp, ISP_LOGDEBUG1,
1975 "Setting ICB Port 0x%08x%08x",
1976 ((uint32_t) (pwwn >> 32)),
1977 ((uint32_t) (pwwn & 0xffffffff)));
1978 } else {
1979 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1980 return;
1981 }
1982 icbp->icb_retry_count = fcp->isp_retry_count;
1983
1984 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1985 if (icbp->icb_rqstqlen < 8) {
1986 isp_prt(isp, ISP_LOGERR, "bad request queue length %d",
1987 icbp->icb_rqstqlen);
1988 return;
1989 }
1990 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1991 if (icbp->icb_rsltqlen < 8) {
1992 isp_prt(isp, ISP_LOGERR, "bad result queue length %d",
1993 icbp->icb_rsltqlen);
1994 return;
1995 }
1996 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1997 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1998 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1999 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
2000
2001 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
2002 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
2003 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
2004 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
2005
2006#ifdef ISP_TARGET_MODE
2007 if (isp->isp_role & ISP_ROLE_TARGET) {
2008 icbp->icb_atioqlen = RESULT_QUEUE_LEN(isp);
2009 if (icbp->icb_atioqlen < 8) {
2010 isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d",
2011 icbp->icb_atioqlen);
2012 return;
2013 }
2014 icbp->icb_atioqaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_atioq_dma);
2015 icbp->icb_atioqaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_atioq_dma);
2016 icbp->icb_atioqaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_atioq_dma);
2017 icbp->icb_atioqaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_atioq_dma);
2018 isp_prt(isp, ISP_LOGDEBUG0,
2019 "isp_fibre_init_2400: atioq %04x%04x%04x%04x",
2020 DMA_WD3(isp->isp_atioq_dma), DMA_WD2(isp->isp_atioq_dma),
2021 DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
2022 }
2023#endif
2024
2025 isp_prt(isp, ISP_LOGDEBUG0,
2026 "isp_fibre_init_2400: fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
2027 icbp->icb_fwoptions1, icbp->icb_fwoptions2, icbp->icb_fwoptions3);
2028
2029 isp_prt(isp, ISP_LOGDEBUG0,
2030 "isp_fibre_init_2400: rqst %04x%04x%04x%04x rsp %04x%04x%04x%04x",
2031 DMA_WD3(isp->isp_rquest_dma), DMA_WD2(isp->isp_rquest_dma),
2032 DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma),
2033 DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
2034 DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
2035
2036 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2037 isp_print_bytes(isp, "isp_fibre_init_2400", sizeof (*icbp),
2038 icbp);
2039 }
2040 FC_SCRATCH_ACQUIRE(isp);
2041 isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
2042
2043
2044 /*
2045 * Init the firmware
2046 */
2047 MEMZERO(&mbs, sizeof (mbs));
2048 mbs.param[0] = MBOX_INIT_FIRMWARE;
2049 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2050 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2051 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2052 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2053 mbs.logval = MBLOGALL;
2054 mbs.timeout = 30 * 1000000;
2055 isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %04x%04x%04x%04x",
2056 DMA_WD3(fcp->isp_scdma), DMA_WD2(fcp->isp_scdma),
2057 DMA_WD1(fcp->isp_scdma), DMA_WD0(fcp->isp_scdma));
2058 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp));
2059 isp_mboxcmd(isp, &mbs);
2060 FC_SCRATCH_RELEASE(isp);
2061 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2062 return;
2063 }
2064 isp->isp_reqidx = 0;
2065 isp->isp_reqodx = 0;
2066 isp->isp_residx = 0;
2067
2068 /*
2069 * Whatever happens, we're now committed to being here.
2070 */
2071 isp->isp_state = ISP_INITSTATE;
2072}
2073
2074static void
2075isp_mark_portdb(ispsoftc_t *isp, int onprobation)
2076{
2077 fcparam *fcp = (fcparam *) isp->isp_param;
2078 int i;
2079
2080 for (i = 0; i < MAX_FC_TARG; i++) {
2081 if (onprobation == 0) {
2082 MEMZERO(&fcp->portdb[i], sizeof (fcportdb_t));
2083 } else {
2084 switch (fcp->portdb[i].state) {
2085 case FC_PORTDB_STATE_CHANGED:
2086 case FC_PORTDB_STATE_PENDING_VALID:
2087 case FC_PORTDB_STATE_VALID:
2088 case FC_PORTDB_STATE_PROBATIONAL:
2089 fcp->portdb[i].state =
2090 FC_PORTDB_STATE_PROBATIONAL;
2091 break;
2092 case FC_PORTDB_STATE_ZOMBIE:
2093 break;
2094 case FC_PORTDB_STATE_NIL:
2095 default:
2096 MEMZERO(&fcp->portdb[i], sizeof (fcportdb_t));
2097 fcp->portdb[i].state =
2098 FC_PORTDB_STATE_NIL;
2099 break;
2100 }
2101 }
2102 }
2103}
2104
2105/*
2106 * Perform an IOCB PLOGI or LOGO via EXECUTE IOCB A64 for 24XX cards
2107 * or via FABRIC LOGIN/FABRIC LOGOUT for other cards.
2108 */
2109static int
2110isp_plogx(ispsoftc_t *isp, uint16_t handle, uint32_t portid, int flags, int gs)
2111{
2112 mbreg_t mbs;
2113 uint8_t q[QENTRY_LEN];
2114 isp_plogx_t *plp;
2115 uint8_t *scp;
2116 uint32_t sst, parm1;
2117 int rval;
2118
2119 if (!IS_24XX(isp)) {
2120 int action = flags & PLOGX_FLG_CMD_MASK;
2121 if (action == PLOGX_FLG_CMD_PLOGI) {
2122 return (isp_port_login(isp, handle, portid));
2123 } else if (action == PLOGX_FLG_CMD_LOGO) {
2124 return (isp_port_logout(isp, handle, portid));
2125 } else {
2126 return (MBOX_INVALID_COMMAND);
2127 }
2128 }
2129
2130 MEMZERO(q, QENTRY_LEN);
2131 plp = (isp_plogx_t *) q;
2132 plp->plogx_header.rqs_entry_count = 1;
2133 plp->plogx_header.rqs_entry_type = RQSTYPE_LOGIN;
2134 plp->plogx_handle = 0xffffffff;
2135 plp->plogx_nphdl = handle;
2136 plp->plogx_portlo = portid;
2137 plp->plogx_rspsz_porthi = (portid >> 16) & 0xff;
2138 plp->plogx_flags = flags;
2139
2140 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2141 isp_print_bytes(isp, "IOCB LOGX", QENTRY_LEN, plp);
2142 }
2143
2144 if (gs == 0) {
2145 FC_SCRATCH_ACQUIRE(isp);
2146 }
2147 scp = FCPARAM(isp)->isp_scratch;
2148 isp_put_plogx(isp, plp, (isp_plogx_t *) scp);
2149
2150
2151 MEMZERO(&mbs, sizeof (mbs));
2152 mbs.param[0] = MBOX_EXEC_COMMAND_IOCB_A64;
2153 mbs.param[1] = QENTRY_LEN;
2154 mbs.param[2] = DMA_WD1(FCPARAM(isp)->isp_scdma);
2155 mbs.param[3] = DMA_WD0(FCPARAM(isp)->isp_scdma);
2156 mbs.param[6] = DMA_WD3(FCPARAM(isp)->isp_scdma);
2157 mbs.param[7] = DMA_WD2(FCPARAM(isp)->isp_scdma);
2158 mbs.timeout = 500000;
2159 mbs.logval = MBLOGALL;
2160 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, QENTRY_LEN);
2161 isp_mboxcmd(isp, &mbs);
2162 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2163 rval = mbs.param[0];
2164 goto out;
2165 }
2166 MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN, QENTRY_LEN);
2167 scp += QENTRY_LEN;
2168 isp_get_plogx(isp, (isp_plogx_t *) scp, plp);
2169 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2170 isp_print_bytes(isp, "IOCB LOGX response", QENTRY_LEN, plp);
2171 }
2172
2173 if (plp->plogx_status == PLOGX_STATUS_OK) {
2174 rval = 0;
2175 goto out;
2176 } else if (plp->plogx_status != PLOGX_STATUS_IOCBERR) {
2177 isp_prt(isp, ISP_LOGWARN, "status 0x%x on port login IOCB",
2178 plp->plogx_status);
2179 rval = -1;
2180 goto out;
2181 }
2182
2183 sst = plp->plogx_ioparm[0].lo16 | (plp->plogx_ioparm[0].hi16 << 16);
2184 parm1 = plp->plogx_ioparm[1].lo16 | (plp->plogx_ioparm[1].hi16 << 16);
2185
2186 rval = -1;
2187
2188 switch (sst) {
2189 case PLOGX_IOCBERR_NOLINK:
2190 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no link");
2191 break;
2192 case PLOGX_IOCBERR_NOIOCB:
2193 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no IOCB buffer");
2194 break;
2195 case PLOGX_IOCBERR_NOXGHG:
2196 isp_prt(isp, ISP_LOGERR,
2197 "PLOGX failed- no Exchange Control Block");
2198 break;
2199 case PLOGX_IOCBERR_FAILED:
2200 isp_prt(isp, ISP_LOGERR,
2201 "PLOGX(0x%x) of Port 0x%06x failed: reason 0x%x (last LOGIN"
2202 " state 0x%x)", flags, portid, parm1 & 0xff,
2203 (parm1 >> 8) & 0xff);
2204 break;
2205 case PLOGX_IOCBERR_NOFABRIC:
2206 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no fabric");
2207 break;
2208 case PLOGX_IOCBERR_NOTREADY:
2209 isp_prt(isp, ISP_LOGERR, "PLOGX failed- f/w not ready");
2210 break;
2211 case PLOGX_IOCBERR_NOLOGIN:
2212 isp_prt(isp, ISP_LOGERR,
2213 "PLOGX failed- not logged in (last LOGIN state 0x%x)",
2214 parm1);
2215 rval = MBOX_NOT_LOGGED_IN;
2216 break;
2217 case PLOGX_IOCBERR_REJECT:
2218 isp_prt(isp, ISP_LOGERR, "PLOGX failed: LS_RJT = 0x%x", parm1);
2219 break;
2220 case PLOGX_IOCBERR_NOPCB:
2221 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no PCB allocated");
2222 break;
2223 case PLOGX_IOCBERR_EINVAL:
2224 isp_prt(isp, ISP_LOGERR,
2225 "PLOGX failed: invalid parameter at offset 0x%x", parm1);
2226 break;
2227 case PLOGX_IOCBERR_PORTUSED:
2228 isp_prt(isp, ISP_LOGDEBUG0,
2229 "portid 0x%x already logged in with N-port handle 0x%x",
2230 portid, parm1);
2231 rval = MBOX_PORT_ID_USED | (handle << 16);
2232 break;
2233 case PLOGX_IOCBERR_HNDLUSED:
2234 isp_prt(isp, ISP_LOGDEBUG0,
2235 "N-port handle 0x%x already used for portid 0x%x",
2236 handle, parm1);
2237 rval = MBOX_LOOP_ID_USED;
2238 break;
2239 case PLOGX_IOCBERR_NOHANDLE:
2240 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no handle allocated");
2241 break;
2242 case PLOGX_IOCBERR_NOFLOGI:
2243 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no FLOGI_ACC");
2244 break;
2245 default:
2246 isp_prt(isp, ISP_LOGERR, "status %x from %x", plp->plogx_status,
2247 flags);
2248 rval = -1;
2249 break;
2250 }
2251out:
2252 if (gs == 0) {
2253 FC_SCRATCH_RELEASE(isp);
2254 }
2255 return (rval);
2256}
2257
2258static int
2259isp_port_login(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2260{
2261 mbreg_t mbs;
2262
2263 MEMZERO(&mbs, sizeof (mbs));
2264 mbs.param[0] = MBOX_FABRIC_LOGIN;
2265 if (FCPARAM(isp)->isp_2klogin) {
2266 mbs.param[1] = handle;
2267 mbs.ibits = (1 << 10);
2268 } else {
2269 mbs.param[1] = handle << 8;
2270 }
2271 mbs.param[2] = portid >> 16;
2272 mbs.param[3] = portid;
2273 mbs.logval = MBLOGNONE;
2274 mbs.timeout = 500000;
2275 isp_mboxcmd(isp, &mbs);
2276
2277 switch (mbs.param[0]) {
2278 case MBOX_PORT_ID_USED:
2279 isp_prt(isp, ISP_LOGDEBUG0,
2280 "isp_plogi_old: portid 0x%06x already logged in as %u",
2281 portid, mbs.param[1]);
2282 return (MBOX_PORT_ID_USED | (mbs.param[1] << 16));
| 1890 icbp->icb_fwoptions1 |= ICB2400_OPT1_HARD_ADDRESS;
1891 }
1892
1893 icbp->icb_fwoptions2 = fcp->isp_xfwoptions;
1894 switch(isp->isp_confopts & ISP_CFG_PORT_PREF) {
1895 case ISP_CFG_NPORT:
1896 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1897 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_2_LOOP;
1898 break;
1899 case ISP_CFG_NPORT_ONLY:
1900 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1901 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_ONLY;
1902 break;
1903 case ISP_CFG_LPORT_ONLY:
1904 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1905 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_ONLY;
1906 break;
1907 default:
1908 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1909 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
1910 break;
1911 }
1912
1913 switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK) {
1914 case ICB2400_OPT2_ZIO:
1915 case ICB2400_OPT2_ZIO1:
1916 icbp->icb_idelaytimer = 0;
1917 break;
1918 case 0:
1919 break;
1920 default:
1921 isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field",
1922 icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
1923 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TIMER_MASK;
1924 break;
1925 }
1926
1927 icbp->icb_fwoptions3 = fcp->isp_zfwoptions;
1928 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_AUTO;
1929 if (isp->isp_confopts & ISP_CFG_ONEGB) {
1930 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_ONEGB;
1931 } else if (isp->isp_confopts & ISP_CFG_TWOGB) {
1932 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_TWOGB;
1933 } else if (isp->isp_confopts & ISP_CFG_FOURGB) {
1934 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_FOURGB;
1935 } else {
1936 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_AUTO;
1937 }
1938
1939 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
1940 icbp->icb_fwoptions3 |= ICB2400_OPT3_SOFTID;
1941 }
1942 icbp->icb_logintime = ICB_LOGIN_TOV;
1943
1944 nwwn = ISP_NODEWWN(isp);
1945 pwwn = ISP_PORTWWN(isp);
1946
1947 if (nwwn && pwwn) {
1948 icbp->icb_fwoptions1 |= ICB2400_OPT1_BOTH_WWNS;
1949 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn);
1950 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1951 isp_prt(isp, ISP_LOGDEBUG1,
1952 "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1953 ((uint32_t) (nwwn >> 32)),
1954 ((uint32_t) (nwwn & 0xffffffff)),
1955 ((uint32_t) (pwwn >> 32)),
1956 ((uint32_t) (pwwn & 0xffffffff)));
1957 } else if (pwwn) {
1958 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_BOTH_WWNS;
1959 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1960 isp_prt(isp, ISP_LOGDEBUG1,
1961 "Setting ICB Port 0x%08x%08x",
1962 ((uint32_t) (pwwn >> 32)),
1963 ((uint32_t) (pwwn & 0xffffffff)));
1964 } else {
1965 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1966 return;
1967 }
1968 icbp->icb_retry_count = fcp->isp_retry_count;
1969
1970 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1971 if (icbp->icb_rqstqlen < 8) {
1972 isp_prt(isp, ISP_LOGERR, "bad request queue length %d",
1973 icbp->icb_rqstqlen);
1974 return;
1975 }
1976 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1977 if (icbp->icb_rsltqlen < 8) {
1978 isp_prt(isp, ISP_LOGERR, "bad result queue length %d",
1979 icbp->icb_rsltqlen);
1980 return;
1981 }
1982 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1983 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1984 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1985 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1986
1987 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1988 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1989 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1990 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1991
1992#ifdef ISP_TARGET_MODE
1993 if (isp->isp_role & ISP_ROLE_TARGET) {
1994 icbp->icb_atioqlen = RESULT_QUEUE_LEN(isp);
1995 if (icbp->icb_atioqlen < 8) {
1996 isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d",
1997 icbp->icb_atioqlen);
1998 return;
1999 }
2000 icbp->icb_atioqaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_atioq_dma);
2001 icbp->icb_atioqaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_atioq_dma);
2002 icbp->icb_atioqaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_atioq_dma);
2003 icbp->icb_atioqaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_atioq_dma);
2004 isp_prt(isp, ISP_LOGDEBUG0,
2005 "isp_fibre_init_2400: atioq %04x%04x%04x%04x",
2006 DMA_WD3(isp->isp_atioq_dma), DMA_WD2(isp->isp_atioq_dma),
2007 DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
2008 }
2009#endif
2010
2011 isp_prt(isp, ISP_LOGDEBUG0,
2012 "isp_fibre_init_2400: fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
2013 icbp->icb_fwoptions1, icbp->icb_fwoptions2, icbp->icb_fwoptions3);
2014
2015 isp_prt(isp, ISP_LOGDEBUG0,
2016 "isp_fibre_init_2400: rqst %04x%04x%04x%04x rsp %04x%04x%04x%04x",
2017 DMA_WD3(isp->isp_rquest_dma), DMA_WD2(isp->isp_rquest_dma),
2018 DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma),
2019 DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
2020 DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
2021
2022 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2023 isp_print_bytes(isp, "isp_fibre_init_2400", sizeof (*icbp),
2024 icbp);
2025 }
2026 FC_SCRATCH_ACQUIRE(isp);
2027 isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
2028
2029
2030 /*
2031 * Init the firmware
2032 */
2033 MEMZERO(&mbs, sizeof (mbs));
2034 mbs.param[0] = MBOX_INIT_FIRMWARE;
2035 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2036 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2037 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2038 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2039 mbs.logval = MBLOGALL;
2040 mbs.timeout = 30 * 1000000;
2041 isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %04x%04x%04x%04x",
2042 DMA_WD3(fcp->isp_scdma), DMA_WD2(fcp->isp_scdma),
2043 DMA_WD1(fcp->isp_scdma), DMA_WD0(fcp->isp_scdma));
2044 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp));
2045 isp_mboxcmd(isp, &mbs);
2046 FC_SCRATCH_RELEASE(isp);
2047 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2048 return;
2049 }
2050 isp->isp_reqidx = 0;
2051 isp->isp_reqodx = 0;
2052 isp->isp_residx = 0;
2053
2054 /*
2055 * Whatever happens, we're now committed to being here.
2056 */
2057 isp->isp_state = ISP_INITSTATE;
2058}
2059
2060static void
2061isp_mark_portdb(ispsoftc_t *isp, int onprobation)
2062{
2063 fcparam *fcp = (fcparam *) isp->isp_param;
2064 int i;
2065
2066 for (i = 0; i < MAX_FC_TARG; i++) {
2067 if (onprobation == 0) {
2068 MEMZERO(&fcp->portdb[i], sizeof (fcportdb_t));
2069 } else {
2070 switch (fcp->portdb[i].state) {
2071 case FC_PORTDB_STATE_CHANGED:
2072 case FC_PORTDB_STATE_PENDING_VALID:
2073 case FC_PORTDB_STATE_VALID:
2074 case FC_PORTDB_STATE_PROBATIONAL:
2075 fcp->portdb[i].state =
2076 FC_PORTDB_STATE_PROBATIONAL;
2077 break;
2078 case FC_PORTDB_STATE_ZOMBIE:
2079 break;
2080 case FC_PORTDB_STATE_NIL:
2081 default:
2082 MEMZERO(&fcp->portdb[i], sizeof (fcportdb_t));
2083 fcp->portdb[i].state =
2084 FC_PORTDB_STATE_NIL;
2085 break;
2086 }
2087 }
2088 }
2089}
2090
2091/*
2092 * Perform an IOCB PLOGI or LOGO via EXECUTE IOCB A64 for 24XX cards
2093 * or via FABRIC LOGIN/FABRIC LOGOUT for other cards.
2094 */
2095static int
2096isp_plogx(ispsoftc_t *isp, uint16_t handle, uint32_t portid, int flags, int gs)
2097{
2098 mbreg_t mbs;
2099 uint8_t q[QENTRY_LEN];
2100 isp_plogx_t *plp;
2101 uint8_t *scp;
2102 uint32_t sst, parm1;
2103 int rval;
2104
2105 if (!IS_24XX(isp)) {
2106 int action = flags & PLOGX_FLG_CMD_MASK;
2107 if (action == PLOGX_FLG_CMD_PLOGI) {
2108 return (isp_port_login(isp, handle, portid));
2109 } else if (action == PLOGX_FLG_CMD_LOGO) {
2110 return (isp_port_logout(isp, handle, portid));
2111 } else {
2112 return (MBOX_INVALID_COMMAND);
2113 }
2114 }
2115
2116 MEMZERO(q, QENTRY_LEN);
2117 plp = (isp_plogx_t *) q;
2118 plp->plogx_header.rqs_entry_count = 1;
2119 plp->plogx_header.rqs_entry_type = RQSTYPE_LOGIN;
2120 plp->plogx_handle = 0xffffffff;
2121 plp->plogx_nphdl = handle;
2122 plp->plogx_portlo = portid;
2123 plp->plogx_rspsz_porthi = (portid >> 16) & 0xff;
2124 plp->plogx_flags = flags;
2125
2126 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2127 isp_print_bytes(isp, "IOCB LOGX", QENTRY_LEN, plp);
2128 }
2129
2130 if (gs == 0) {
2131 FC_SCRATCH_ACQUIRE(isp);
2132 }
2133 scp = FCPARAM(isp)->isp_scratch;
2134 isp_put_plogx(isp, plp, (isp_plogx_t *) scp);
2135
2136
2137 MEMZERO(&mbs, sizeof (mbs));
2138 mbs.param[0] = MBOX_EXEC_COMMAND_IOCB_A64;
2139 mbs.param[1] = QENTRY_LEN;
2140 mbs.param[2] = DMA_WD1(FCPARAM(isp)->isp_scdma);
2141 mbs.param[3] = DMA_WD0(FCPARAM(isp)->isp_scdma);
2142 mbs.param[6] = DMA_WD3(FCPARAM(isp)->isp_scdma);
2143 mbs.param[7] = DMA_WD2(FCPARAM(isp)->isp_scdma);
2144 mbs.timeout = 500000;
2145 mbs.logval = MBLOGALL;
2146 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, QENTRY_LEN);
2147 isp_mboxcmd(isp, &mbs);
2148 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2149 rval = mbs.param[0];
2150 goto out;
2151 }
2152 MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN, QENTRY_LEN);
2153 scp += QENTRY_LEN;
2154 isp_get_plogx(isp, (isp_plogx_t *) scp, plp);
2155 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2156 isp_print_bytes(isp, "IOCB LOGX response", QENTRY_LEN, plp);
2157 }
2158
2159 if (plp->plogx_status == PLOGX_STATUS_OK) {
2160 rval = 0;
2161 goto out;
2162 } else if (plp->plogx_status != PLOGX_STATUS_IOCBERR) {
2163 isp_prt(isp, ISP_LOGWARN, "status 0x%x on port login IOCB",
2164 plp->plogx_status);
2165 rval = -1;
2166 goto out;
2167 }
2168
2169 sst = plp->plogx_ioparm[0].lo16 | (plp->plogx_ioparm[0].hi16 << 16);
2170 parm1 = plp->plogx_ioparm[1].lo16 | (plp->plogx_ioparm[1].hi16 << 16);
2171
2172 rval = -1;
2173
2174 switch (sst) {
2175 case PLOGX_IOCBERR_NOLINK:
2176 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no link");
2177 break;
2178 case PLOGX_IOCBERR_NOIOCB:
2179 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no IOCB buffer");
2180 break;
2181 case PLOGX_IOCBERR_NOXGHG:
2182 isp_prt(isp, ISP_LOGERR,
2183 "PLOGX failed- no Exchange Control Block");
2184 break;
2185 case PLOGX_IOCBERR_FAILED:
2186 isp_prt(isp, ISP_LOGERR,
2187 "PLOGX(0x%x) of Port 0x%06x failed: reason 0x%x (last LOGIN"
2188 " state 0x%x)", flags, portid, parm1 & 0xff,
2189 (parm1 >> 8) & 0xff);
2190 break;
2191 case PLOGX_IOCBERR_NOFABRIC:
2192 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no fabric");
2193 break;
2194 case PLOGX_IOCBERR_NOTREADY:
2195 isp_prt(isp, ISP_LOGERR, "PLOGX failed- f/w not ready");
2196 break;
2197 case PLOGX_IOCBERR_NOLOGIN:
2198 isp_prt(isp, ISP_LOGERR,
2199 "PLOGX failed- not logged in (last LOGIN state 0x%x)",
2200 parm1);
2201 rval = MBOX_NOT_LOGGED_IN;
2202 break;
2203 case PLOGX_IOCBERR_REJECT:
2204 isp_prt(isp, ISP_LOGERR, "PLOGX failed: LS_RJT = 0x%x", parm1);
2205 break;
2206 case PLOGX_IOCBERR_NOPCB:
2207 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no PCB allocated");
2208 break;
2209 case PLOGX_IOCBERR_EINVAL:
2210 isp_prt(isp, ISP_LOGERR,
2211 "PLOGX failed: invalid parameter at offset 0x%x", parm1);
2212 break;
2213 case PLOGX_IOCBERR_PORTUSED:
2214 isp_prt(isp, ISP_LOGDEBUG0,
2215 "portid 0x%x already logged in with N-port handle 0x%x",
2216 portid, parm1);
2217 rval = MBOX_PORT_ID_USED | (handle << 16);
2218 break;
2219 case PLOGX_IOCBERR_HNDLUSED:
2220 isp_prt(isp, ISP_LOGDEBUG0,
2221 "N-port handle 0x%x already used for portid 0x%x",
2222 handle, parm1);
2223 rval = MBOX_LOOP_ID_USED;
2224 break;
2225 case PLOGX_IOCBERR_NOHANDLE:
2226 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no handle allocated");
2227 break;
2228 case PLOGX_IOCBERR_NOFLOGI:
2229 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no FLOGI_ACC");
2230 break;
2231 default:
2232 isp_prt(isp, ISP_LOGERR, "status %x from %x", plp->plogx_status,
2233 flags);
2234 rval = -1;
2235 break;
2236 }
2237out:
2238 if (gs == 0) {
2239 FC_SCRATCH_RELEASE(isp);
2240 }
2241 return (rval);
2242}
2243
2244static int
2245isp_port_login(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2246{
2247 mbreg_t mbs;
2248
2249 MEMZERO(&mbs, sizeof (mbs));
2250 mbs.param[0] = MBOX_FABRIC_LOGIN;
2251 if (FCPARAM(isp)->isp_2klogin) {
2252 mbs.param[1] = handle;
2253 mbs.ibits = (1 << 10);
2254 } else {
2255 mbs.param[1] = handle << 8;
2256 }
2257 mbs.param[2] = portid >> 16;
2258 mbs.param[3] = portid;
2259 mbs.logval = MBLOGNONE;
2260 mbs.timeout = 500000;
2261 isp_mboxcmd(isp, &mbs);
2262
2263 switch (mbs.param[0]) {
2264 case MBOX_PORT_ID_USED:
2265 isp_prt(isp, ISP_LOGDEBUG0,
2266 "isp_plogi_old: portid 0x%06x already logged in as %u",
2267 portid, mbs.param[1]);
2268 return (MBOX_PORT_ID_USED | (mbs.param[1] << 16));
|
2283 break;
| |
2284
2285 case MBOX_LOOP_ID_USED:
2286 isp_prt(isp, ISP_LOGDEBUG0,
2287 "isp_plogi_old: handle %u in use for port id 0x%02xXXXX",
2288 handle, mbs.param[1] & 0xff);
2289 return (MBOX_LOOP_ID_USED);
2290
2291 case MBOX_COMMAND_COMPLETE:
2292 return (0);
2293
2294 case MBOX_COMMAND_ERROR:
2295 isp_prt(isp, ISP_LOGINFO,
2296 "isp_plogi_old: error 0x%x in PLOGI to port 0x%06x",
2297 mbs.param[1], portid);
2298 return (MBOX_COMMAND_ERROR);
2299
2300 case MBOX_ALL_IDS_USED:
2301 isp_prt(isp, ISP_LOGINFO,
2302 "isp_plogi_old: all IDs used for fabric login");
2303 return (MBOX_ALL_IDS_USED);
2304
2305 default:
2306 isp_prt(isp, ISP_LOGINFO,
2307 "isp_plogi_old: error 0x%x on port login of 0x%06x@0x%0x",
2308 mbs.param[0], portid, handle);
2309 return (mbs.param[0]);
2310 }
2311}
2312
2313static int
2314isp_port_logout(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2315{
2316 mbreg_t mbs;
2317
2318 MEMZERO(&mbs, sizeof (mbs));
2319 mbs.param[0] = MBOX_FABRIC_LOGOUT;
2320 if (FCPARAM(isp)->isp_2klogin) {
2321 mbs.param[1] = handle;
2322 mbs.ibits = (1 << 10);
2323 } else {
2324 mbs.param[1] = handle << 8;
2325 }
2326 mbs.logval = MBLOGNONE;
2327 mbs.timeout = 100000;
2328 isp_mboxcmd(isp, &mbs);
2329 return (mbs.param[0] == MBOX_COMMAND_COMPLETE? 0 : mbs.param[0]);
2330}
2331
2332static int
2333isp_getpdb(ispsoftc_t *isp, uint16_t id, isp_pdb_t *pdb, int dolock)
2334{
2335 fcparam *fcp = (fcparam *) isp->isp_param;
2336 mbreg_t mbs;
2337 union {
2338 isp_pdb_21xx_t fred;
2339 isp_pdb_24xx_t bill;
2340 } un;
2341
2342 MEMZERO(&mbs, sizeof (mbs));
2343 mbs.param[0] = MBOX_GET_PORT_DB;
2344 if (IS_24XX(isp)) {
2345 mbs.ibits = 0x3ff;
2346 mbs.param[1] = id;
2347 } else if (FCPARAM(isp)->isp_2klogin) {
2348 mbs.param[1] = id;
2349 mbs.ibits = (1 << 10);
2350 } else {
2351 mbs.param[1] = id << 8;
2352 }
2353 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2354 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2355 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2356 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2357 mbs.timeout = 250000;
2358 mbs.logval = MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR;
2359 if (dolock) {
2360 FC_SCRATCH_ACQUIRE(isp);
2361 }
2362 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (un));
2363 isp_mboxcmd(isp, &mbs);
2364 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2365 if (dolock) {
2366 FC_SCRATCH_RELEASE(isp);
2367 }
2368 return (-1);
2369 }
2370 if (IS_24XX(isp)) {
2371 isp_get_pdb_24xx(isp, fcp->isp_scratch, &un.bill);
2372 pdb->handle = un.bill.pdb_handle;
2373 pdb->s3_role = un.bill.pdb_prli_svc3;
2374 pdb->portid = BITS2WORD_24XX(un.bill.pdb_portid_bits);
2375 MEMCPY(pdb->portname, un.bill.pdb_portname, 8);
2376 MEMCPY(pdb->nodename, un.bill.pdb_nodename, 8);
2377 } else {
2378 isp_get_pdb_21xx(isp, fcp->isp_scratch, &un.fred);
2379 pdb->handle = un.fred.pdb_loopid;
2380 pdb->s3_role = un.fred.pdb_prli_svc3;
2381 pdb->portid = BITS2WORD(un.fred.pdb_portid_bits);
2382 MEMCPY(pdb->portname, un.fred.pdb_portname, 8);
2383 MEMCPY(pdb->nodename, un.fred.pdb_nodename, 8);
2384 }
2385 if (dolock) {
2386 FC_SCRATCH_RELEASE(isp);
2387 }
2388 return (0);
2389}
2390
2391static uint64_t
2392isp_get_portname(ispsoftc_t *isp, int loopid, int nodename)
2393{
2394 uint64_t wwn = (uint64_t) -1;
2395 mbreg_t mbs;
2396
2397 MEMZERO(&mbs, sizeof (mbs));
2398 mbs.param[0] = MBOX_GET_PORT_NAME;
2399 if (FCPARAM(isp)->isp_2klogin || IS_24XX(isp)) {
2400 mbs.param[1] = loopid;
2401 mbs.ibits = (1 << 10);
2402 if (nodename) {
2403 mbs.param[10] = 1;
2404 }
2405 } else {
2406 mbs.param[1] = loopid << 8;
2407 if (nodename) {
2408 mbs.param[1] |= 1;
2409 }
2410 }
2411 mbs.logval = MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR;
2412 isp_mboxcmd(isp, &mbs);
2413 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2414 return (wwn);
2415 }
2416 if (IS_24XX(isp)) {
2417 wwn =
2418 (((uint64_t)(mbs.param[2] >> 8)) << 56) |
2419 (((uint64_t)(mbs.param[2] & 0xff)) << 48) |
2420 (((uint64_t)(mbs.param[3] >> 8)) << 40) |
2421 (((uint64_t)(mbs.param[3] & 0xff)) << 32) |
2422 (((uint64_t)(mbs.param[6] >> 8)) << 24) |
2423 (((uint64_t)(mbs.param[6] & 0xff)) << 16) |
2424 (((uint64_t)(mbs.param[7] >> 8)) << 8) |
2425 (((uint64_t)(mbs.param[7] & 0xff)));
2426 } else {
2427 wwn =
2428 (((uint64_t)(mbs.param[2] & 0xff)) << 56) |
2429 (((uint64_t)(mbs.param[2] >> 8)) << 48) |
2430 (((uint64_t)(mbs.param[3] & 0xff)) << 40) |
2431 (((uint64_t)(mbs.param[3] >> 8)) << 32) |
2432 (((uint64_t)(mbs.param[6] & 0xff)) << 24) |
2433 (((uint64_t)(mbs.param[6] >> 8)) << 16) |
2434 (((uint64_t)(mbs.param[7] & 0xff)) << 8) |
2435 (((uint64_t)(mbs.param[7] >> 8)));
2436 }
2437 return (wwn);
2438}
2439
2440/*
2441 * Make sure we have good FC link.
2442 */
2443
2444static int
2445isp_fclink_test(ispsoftc_t *isp, int usdelay)
2446{
2447 static const char *toponames[] = {
2448 "Private Loop",
2449 "FL Port",
2450 "N-Port to N-Port",
2451 "F Port",
2452 "F Port (no FLOGI_ACC response)"
2453 };
2454 mbreg_t mbs;
2455 int count, check_for_fabric;
2456 uint8_t lwfs;
2457 int loopid;
2458 fcparam *fcp;
2459 fcportdb_t *lp;
2460 isp_pdb_t pdb;
2461
2462 fcp = isp->isp_param;
2463
2464 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Link Test Entry");
2465 ISP_MARK_PORTDB(isp, 1);
2466
2467 /*
2468 * Wait up to N microseconds for F/W to go to a ready state.
2469 */
2470 lwfs = FW_CONFIG_WAIT;
2471 count = 0;
2472 while (count < usdelay) {
2473 uint64_t enano;
2474 uint32_t wrk;
2475 NANOTIME_T hra, hrb;
2476
2477 GET_NANOTIME(&hra);
2478 isp_fw_state(isp);
2479 if (lwfs != fcp->isp_fwstate) {
2480 isp_prt(isp, ISP_LOGCONFIG|ISP_LOGSANCFG,
2481 "Firmware State <%s->%s>",
2482 ispfc_fw_statename((int)lwfs),
2483 ispfc_fw_statename((int)fcp->isp_fwstate));
2484 lwfs = fcp->isp_fwstate;
2485 }
2486 if (fcp->isp_fwstate == FW_READY) {
2487 break;
2488 }
2489 GET_NANOTIME(&hrb);
2490
2491 /*
2492 * Get the elapsed time in nanoseconds.
2493 * Always guaranteed to be non-zero.
2494 */
2495 enano = NANOTIME_SUB(&hrb, &hra);
2496
2497 isp_prt(isp, ISP_LOGDEBUG1,
2498 "usec%d: 0x%lx->0x%lx enano 0x%x%08x",
2499 count, (long) GET_NANOSEC(&hra), (long) GET_NANOSEC(&hrb),
2500 (uint32_t)(enano >> 32), (uint32_t)(enano & 0xffffffff));
2501
2502 /*
2503 * If the elapsed time is less than 1 millisecond,
2504 * delay a period of time up to that millisecond of
2505 * waiting.
2506 *
2507 * This peculiar code is an attempt to try and avoid
2508 * invoking uint64_t math support functions for some
2509 * platforms where linkage is a problem.
2510 */
2511 if (enano < (1000 * 1000)) {
2512 count += 1000;
2513 enano = (1000 * 1000) - enano;
2514 while (enano > (uint64_t) 4000000000U) {
2515 USEC_SLEEP(isp, 4000000);
2516 enano -= (uint64_t) 4000000000U;
2517 }
2518 wrk = enano;
2519 wrk /= 1000;
2520 USEC_SLEEP(isp, wrk);
2521 } else {
2522 while (enano > (uint64_t) 4000000000U) {
2523 count += 4000000;
2524 enano -= (uint64_t) 4000000000U;
2525 }
2526 wrk = enano;
2527 count += (wrk / 1000);
2528 }
2529 }
2530
2531 /*
2532 * If we haven't gone to 'ready' state, return.
2533 */
2534 if (fcp->isp_fwstate != FW_READY) {
2535 isp_prt(isp, ISP_LOGSANCFG,
2536 "isp_fclink_test: not at FW_READY state");
2537 return (-1);
2538 }
2539
2540 /*
2541 * Get our Loop ID and Port ID.
2542 */
2543 MEMZERO(&mbs, sizeof (mbs));
2544 mbs.param[0] = MBOX_GET_LOOP_ID;
2545 mbs.logval = MBLOGALL;
2546 isp_mboxcmd(isp, &mbs);
2547 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2548 return (-1);
2549 }
2550
2551 if (FCPARAM(isp)->isp_2klogin) {
2552 fcp->isp_loopid = mbs.param[1];
2553 } else {
2554 fcp->isp_loopid = mbs.param[1] & 0xff;
2555 }
2556
2557 if (IS_2100(isp)) {
2558 fcp->isp_topo = TOPO_NL_PORT;
2559 } else {
2560 int topo = (int) mbs.param[6];
2561 if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB) {
2562 topo = TOPO_PTP_STUB;
2563 }
2564 fcp->isp_topo = topo;
2565 }
2566 fcp->isp_portid = mbs.param[2] | (mbs.param[3] << 16);
2567
2568 if (IS_2100(isp)) {
2569 /*
2570 * Don't bother with fabric if we are using really old
2571 * 2100 firmware. It's just not worth it.
2572 */
2573 if (ISP_FW_NEWER_THAN(isp, 1, 15, 37)) {
2574 check_for_fabric = 1;
2575 } else {
2576 check_for_fabric = 0;
2577 }
2578 } else if (fcp->isp_topo == TOPO_FL_PORT ||
2579 fcp->isp_topo == TOPO_F_PORT) {
2580 check_for_fabric = 1;
2581 } else {
2582 check_for_fabric = 0;
2583 }
2584
2585 if (IS_24XX(isp)) {
2586 loopid = NPH_FL_ID;
2587 } else {
2588 loopid = FL_ID;
2589 }
2590
2591 if (check_for_fabric && isp_getpdb(isp, loopid, &pdb, 1) == 0) {
2592 int r;
2593 if (IS_2100(isp)) {
2594 fcp->isp_topo = TOPO_FL_PORT;
2595 }
2596 if (pdb.portid == 0) {
2597 /*
2598 * Crock.
2599 */
2600 fcp->isp_topo = TOPO_NL_PORT;
2601 goto not_on_fabric;
2602 }
2603
2604 /*
2605 * Save the Fabric controller's port database entry.
2606 */
2607 lp = &fcp->portdb[FL_ID];
2608 lp->state = FC_PORTDB_STATE_PENDING_VALID;
2609 MAKE_WWN_FROM_NODE_NAME(lp->node_wwn, pdb.nodename);
2610 MAKE_WWN_FROM_NODE_NAME(lp->port_wwn, pdb.portname);
2611 lp->roles = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2612 lp->portid = pdb.portid;
2613 lp->handle = pdb.handle;
2614 lp->new_portid = lp->portid;
2615 lp->new_roles = lp->roles;
2616 if (IS_24XX(isp)) {
2617 r = isp_register_fc4_type_24xx(isp);
2618 } else {
2619 r = isp_register_fc4_type(isp);
2620 }
2621 if (r) {
2622 isp_prt(isp, ISP_LOGSANCFG,
2623 "isp_fclink_test: register fc4 type failed");
2624 return (-1);
2625 }
2626 } else {
2627not_on_fabric:
2628 fcp->portdb[FL_ID].state = FC_PORTDB_STATE_NIL;
2629 }
2630
2631 fcp->isp_gbspeed = 1;
2632 if (IS_23XX(isp) || IS_24XX(isp)) {
2633 MEMZERO(&mbs, sizeof (mbs));
2634 mbs.param[0] = MBOX_GET_SET_DATA_RATE;
2635 mbs.param[1] = MBGSD_GET_RATE;
2636 /* mbs.param[2] undefined if we're just getting rate */
2637 mbs.logval = MBLOGALL;
2638 mbs.timeout = 3000000;
2639 isp_mboxcmd(isp, &mbs);
2640 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
2641 if (mbs.param[1] == MBGSD_FOURGB) {
2642 isp_prt(isp, ISP_LOGINFO, "4Gb link speed/s");
2643 fcp->isp_gbspeed = 4;
2644 } if (mbs.param[1] == MBGSD_TWOGB) {
2645 isp_prt(isp, ISP_LOGINFO, "2Gb link speed/s");
2646 fcp->isp_gbspeed = 2;
2647 }
2648 }
2649 }
2650
2651 /*
2652 * Announce ourselves, too.
2653 */
2654 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGCONFIG, topology, fcp->isp_portid,
2655 fcp->isp_loopid, toponames[fcp->isp_topo]);
2656 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGCONFIG, ourwwn,
2657 (uint32_t) (ISP_NODEWWN(isp) >> 32),
2658 (uint32_t) ISP_NODEWWN(isp),
2659 (uint32_t) (ISP_PORTWWN(isp) >> 32),
2660 (uint32_t) ISP_PORTWWN(isp));
2661 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Link Test Complete");
2662 return (0);
2663}
2664
2665static const char *
2666ispfc_fw_statename(int state)
2667{
2668 switch(state) {
2669 case FW_CONFIG_WAIT: return "Config Wait";
2670 case FW_WAIT_AL_PA: return "Waiting for AL_PA";
2671 case FW_WAIT_LOGIN: return "Wait Login";
2672 case FW_READY: return "Ready";
2673 case FW_LOSS_OF_SYNC: return "Loss Of Sync";
2674 case FW_ERROR: return "Error";
2675 case FW_REINIT: return "Re-Init";
2676 case FW_NON_PART: return "Nonparticipating";
2677 default: return "?????";
2678 }
2679}
2680
2681/*
2682 * Complete the synchronization of our Port Database.
2683 *
2684 * At this point, we've scanned the local loop (if any) and the fabric
2685 * and performed fabric logins on all new devices.
2686 *
2687 * Our task here is to go through our port database and remove any entities
2688 * that are still marked probational (issuing PLOGO for ones which we had
2689 * PLOGI'd into) or are dead.
2690 *
2691 * Our task here is to also check policy to decide whether devices which
2692 * have *changed* in some way should still be kept active. For example,
2693 * if a device has just changed PortID, we can either elect to treat it
2694 * as an old device or as a newly arrived device (and notify the outer
2695 * layer appropriately).
2696 *
2697 * We also do initiator map target id assignment here for new initiator
2698 * devices and refresh old ones ot make sure that they point to the corret
2699 * entities.
2700 */
2701static int
2702isp_pdb_sync(ispsoftc_t *isp)
2703{
2704 fcparam *fcp = isp->isp_param;
2705 fcportdb_t *lp;
2706 uint16_t dbidx;
2707
2708 if (fcp->isp_loopstate == LOOP_READY) {
2709 return (0);
2710 }
2711
2712 /*
2713 * Make sure we're okay for doing this right now.
2714 */
2715 if (fcp->isp_loopstate != LOOP_PDB_RCVD &&
2716 fcp->isp_loopstate != LOOP_FSCAN_DONE &&
2717 fcp->isp_loopstate != LOOP_LSCAN_DONE) {
2718 isp_prt(isp, ISP_LOGWARN, "isp_pdb_sync: bad loopstate %d",
2719 fcp->isp_loopstate);
2720 return (-1);
2721 }
2722
2723 if (fcp->isp_topo == TOPO_FL_PORT ||
2724 fcp->isp_topo == TOPO_NL_PORT ||
2725 fcp->isp_topo == TOPO_N_PORT) {
2726 if (fcp->isp_loopstate < LOOP_LSCAN_DONE) {
2727 if (isp_scan_loop(isp) != 0) {
2728 isp_prt(isp, ISP_LOGWARN,
2729 "isp_pdb_sync: isp_scan_loop failed");
2730 return (-1);
2731 }
2732 }
2733 }
2734
2735 if (fcp->isp_topo == TOPO_F_PORT || fcp->isp_topo == TOPO_FL_PORT) {
2736 if (fcp->isp_loopstate < LOOP_FSCAN_DONE) {
2737 if (isp_scan_fabric(isp) != 0) {
2738 isp_prt(isp, ISP_LOGWARN,
2739 "isp_pdb_sync: isp_scan_fabric failed");
2740 return (-1);
2741 }
2742 }
2743 }
2744
2745 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Synchronizing PDBs");
2746
2747 fcp->isp_loopstate = LOOP_SYNCING_PDB;
2748
2749 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
2750 lp = &fcp->portdb[dbidx];
2751
2752 if (lp->state == FC_PORTDB_STATE_NIL) {
2753 continue;
2754 }
2755
2756 if (lp->state == FC_PORTDB_STATE_VALID) {
2757 if (dbidx != FL_ID) {
2758 isp_prt(isp,
2759 ISP_LOGERR, "portdb idx %d already valid",
2760 dbidx);
2761 }
2762 continue;
2763 }
2764
2765 switch (lp->state) {
2766 case FC_PORTDB_STATE_PROBATIONAL:
2767 case FC_PORTDB_STATE_DEAD:
2768 /*
2769 * It's up to the outer layers to clear isp_ini_map.
2770 */
2771 lp->state = FC_PORTDB_STATE_NIL;
2772 isp_async(isp, ISPASYNC_DEV_GONE, lp);
2773 if (lp->autologin == 0) {
2774 (void) isp_plogx(isp, lp->handle, lp->portid,
2775 PLOGX_FLG_CMD_LOGO |
2776 PLOGX_FLG_IMPLICIT |
2777 PLOGX_FLG_FREE_NPHDL, 0);
2778 } else {
2779 lp->autologin = 0;
2780 }
2781 lp->new_roles = 0;
2782 lp->new_portid = 0;
2783 /*
2784 * Note that we might come out of this with our state
2785 * set to FC_PORTDB_STATE_ZOMBIE.
2786 */
2787 break;
2788 case FC_PORTDB_STATE_NEW:
2789 /*
2790 * It's up to the outer layers to assign a virtual
2791 * target id in isp_ini_map (if any).
2792 */
2793 lp->portid = lp->new_portid;
2794 lp->roles = lp->new_roles;
2795 lp->state = FC_PORTDB_STATE_VALID;
2796 isp_async(isp, ISPASYNC_DEV_ARRIVED, lp);
2797 lp->new_roles = 0;
2798 lp->new_portid = 0;
2799 lp->reserved = 0;
2800 lp->new_reserved = 0;
2801 break;
2802 case FC_PORTDB_STATE_CHANGED:
2803/*
2804 * XXXX FIX THIS
2805 */
2806 lp->state = FC_PORTDB_STATE_VALID;
2807 isp_async(isp, ISPASYNC_DEV_CHANGED, lp);
2808 lp->new_roles = 0;
2809 lp->new_portid = 0;
2810 lp->reserved = 0;
2811 lp->new_reserved = 0;
2812 break;
2813 case FC_PORTDB_STATE_PENDING_VALID:
2814 lp->portid = lp->new_portid;
2815 lp->roles = lp->new_roles;
2816 if (lp->ini_map_idx) {
2817 int t = lp->ini_map_idx - 1;
2818 fcp->isp_ini_map[t] = dbidx + 1;
2819 }
2820 lp->state = FC_PORTDB_STATE_VALID;
2821 isp_async(isp, ISPASYNC_DEV_STAYED, lp);
2822 if (dbidx != FL_ID) {
2823 lp->new_roles = 0;
2824 lp->new_portid = 0;
2825 }
2826 lp->reserved = 0;
2827 lp->new_reserved = 0;
2828 break;
2829 case FC_PORTDB_STATE_ZOMBIE:
2830 break;
2831 default:
2832 isp_prt(isp, ISP_LOGWARN,
2833 "isp_scan_loop: state %d for idx %d",
2834 lp->state, dbidx);
2835 isp_dump_portdb(isp);
2836 }
2837 }
2838
2839 /*
2840 * If we get here, we've for sure seen not only a valid loop
2841 * but know what is or isn't on it, so mark this for usage
2842 * in isp_start.
2843 */
2844 fcp->loop_seen_once = 1;
2845 fcp->isp_loopstate = LOOP_READY;
2846 return (0);
2847}
2848
2849/*
2850 * Scan local loop for devices.
2851 */
2852static int
2853isp_scan_loop(ispsoftc_t *isp)
2854{
2855 fcportdb_t *lp, tmp;
2856 fcparam *fcp = isp->isp_param;
2857 int i;
2858 isp_pdb_t pdb;
2859 uint16_t handle, lim = 0;
2860
2861 if (fcp->isp_fwstate < FW_READY ||
2862 fcp->isp_loopstate < LOOP_PDB_RCVD) {
2863 return (-1);
2864 }
2865
2866 if (fcp->isp_loopstate > LOOP_SCANNING_LOOP) {
2867 return (0);
2868 }
2869
2870 /*
2871 * Check our connection topology.
2872 *
2873 * If we're a public or private loop, we scan 0..125 as handle values.
2874 * The firmware has (typically) peformed a PLOGI for us.
2875 *
2876 * If we're a N-port connection, we treat this is a short loop (0..1).
2877 *
2878 * If we're in target mode, we can all possible handles to see who
2879 * might have logged into us.
2880 */
2881 switch (fcp->isp_topo) {
2882 case TOPO_NL_PORT:
2883 case TOPO_FL_PORT:
2884 lim = LOCAL_LOOP_LIM;
2885 break;
2886 case TOPO_N_PORT:
2887 lim = 2;
2888 break;
2889 default:
2890 isp_prt(isp, ISP_LOGDEBUG0, "no loop topology to scan");
2891 fcp->isp_loopstate = LOOP_LSCAN_DONE;
2892 return (0);
2893 }
2894
2895 fcp->isp_loopstate = LOOP_SCANNING_LOOP;
2896
2897 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC scan loop 0..%d", lim-1);
2898
2899
2900 /*
2901 * Run through the list and get the port database info for each one.
2902 */
2903 for (handle = 0; handle < lim; handle++) {
2904 /*
2905 * But don't even try for ourselves...
2906 */
2907 if (handle == fcp->isp_loopid) {
2908 continue;
2909 }
2910
2911 /*
2912 * In older cards with older f/w GET_PORT_DATABASE has been
2913 * known to hang. This trick gets around that problem.
2914 */
2915 if (IS_2100(isp) || IS_2200(isp)) {
2916 uint64_t node_wwn = isp_get_portname(isp, handle, 1);
2917 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2918 return (-1);
2919 }
2920 if (node_wwn == 0) {
2921 continue;
2922 }
2923 }
2924
2925 /*
2926 * Get the port database entity for this index.
2927 */
2928 if (isp_getpdb(isp, handle, &pdb, 1) != 0) {
2929 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2930 ISP_MARK_PORTDB(isp, 1);
2931 return (-1);
2932 }
2933 continue;
2934 }
2935
2936 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2937 ISP_MARK_PORTDB(isp, 1);
2938 return (-1);
2939 }
2940
2941 /*
2942 * On *very* old 2100 firmware we would end up sometimes
2943 * with the firmware returning the port database entry
2944 * for something else. We used to restart this, but
2945 * now we just punt.
2946 */
2947 if (IS_2100(isp) && pdb.handle != handle) {
2948 isp_prt(isp, ISP_LOGWARN,
2949 "giving up on synchronizing the port database");
2950 ISP_MARK_PORTDB(isp, 1);
2951 return (-1);
2952 }
2953
2954 /*
2955 * Save the pertinent info locally.
2956 */
2957 MAKE_WWN_FROM_NODE_NAME(tmp.node_wwn, pdb.nodename);
2958 MAKE_WWN_FROM_NODE_NAME(tmp.port_wwn, pdb.portname);
2959 tmp.roles = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2960 tmp.portid = pdb.portid;
2961 tmp.handle = pdb.handle;
2962
2963 /*
2964 * Check to make sure it's still a valid entry. The 24XX seems
2965 * to return a portid but not a WWPN/WWNN or role for devices
| 2269
2270 case MBOX_LOOP_ID_USED:
2271 isp_prt(isp, ISP_LOGDEBUG0,
2272 "isp_plogi_old: handle %u in use for port id 0x%02xXXXX",
2273 handle, mbs.param[1] & 0xff);
2274 return (MBOX_LOOP_ID_USED);
2275
2276 case MBOX_COMMAND_COMPLETE:
2277 return (0);
2278
2279 case MBOX_COMMAND_ERROR:
2280 isp_prt(isp, ISP_LOGINFO,
2281 "isp_plogi_old: error 0x%x in PLOGI to port 0x%06x",
2282 mbs.param[1], portid);
2283 return (MBOX_COMMAND_ERROR);
2284
2285 case MBOX_ALL_IDS_USED:
2286 isp_prt(isp, ISP_LOGINFO,
2287 "isp_plogi_old: all IDs used for fabric login");
2288 return (MBOX_ALL_IDS_USED);
2289
2290 default:
2291 isp_prt(isp, ISP_LOGINFO,
2292 "isp_plogi_old: error 0x%x on port login of 0x%06x@0x%0x",
2293 mbs.param[0], portid, handle);
2294 return (mbs.param[0]);
2295 }
2296}
2297
2298static int
2299isp_port_logout(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2300{
2301 mbreg_t mbs;
2302
2303 MEMZERO(&mbs, sizeof (mbs));
2304 mbs.param[0] = MBOX_FABRIC_LOGOUT;
2305 if (FCPARAM(isp)->isp_2klogin) {
2306 mbs.param[1] = handle;
2307 mbs.ibits = (1 << 10);
2308 } else {
2309 mbs.param[1] = handle << 8;
2310 }
2311 mbs.logval = MBLOGNONE;
2312 mbs.timeout = 100000;
2313 isp_mboxcmd(isp, &mbs);
2314 return (mbs.param[0] == MBOX_COMMAND_COMPLETE? 0 : mbs.param[0]);
2315}
2316
2317static int
2318isp_getpdb(ispsoftc_t *isp, uint16_t id, isp_pdb_t *pdb, int dolock)
2319{
2320 fcparam *fcp = (fcparam *) isp->isp_param;
2321 mbreg_t mbs;
2322 union {
2323 isp_pdb_21xx_t fred;
2324 isp_pdb_24xx_t bill;
2325 } un;
2326
2327 MEMZERO(&mbs, sizeof (mbs));
2328 mbs.param[0] = MBOX_GET_PORT_DB;
2329 if (IS_24XX(isp)) {
2330 mbs.ibits = 0x3ff;
2331 mbs.param[1] = id;
2332 } else if (FCPARAM(isp)->isp_2klogin) {
2333 mbs.param[1] = id;
2334 mbs.ibits = (1 << 10);
2335 } else {
2336 mbs.param[1] = id << 8;
2337 }
2338 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2339 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2340 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2341 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2342 mbs.timeout = 250000;
2343 mbs.logval = MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR;
2344 if (dolock) {
2345 FC_SCRATCH_ACQUIRE(isp);
2346 }
2347 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (un));
2348 isp_mboxcmd(isp, &mbs);
2349 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2350 if (dolock) {
2351 FC_SCRATCH_RELEASE(isp);
2352 }
2353 return (-1);
2354 }
2355 if (IS_24XX(isp)) {
2356 isp_get_pdb_24xx(isp, fcp->isp_scratch, &un.bill);
2357 pdb->handle = un.bill.pdb_handle;
2358 pdb->s3_role = un.bill.pdb_prli_svc3;
2359 pdb->portid = BITS2WORD_24XX(un.bill.pdb_portid_bits);
2360 MEMCPY(pdb->portname, un.bill.pdb_portname, 8);
2361 MEMCPY(pdb->nodename, un.bill.pdb_nodename, 8);
2362 } else {
2363 isp_get_pdb_21xx(isp, fcp->isp_scratch, &un.fred);
2364 pdb->handle = un.fred.pdb_loopid;
2365 pdb->s3_role = un.fred.pdb_prli_svc3;
2366 pdb->portid = BITS2WORD(un.fred.pdb_portid_bits);
2367 MEMCPY(pdb->portname, un.fred.pdb_portname, 8);
2368 MEMCPY(pdb->nodename, un.fred.pdb_nodename, 8);
2369 }
2370 if (dolock) {
2371 FC_SCRATCH_RELEASE(isp);
2372 }
2373 return (0);
2374}
2375
2376static uint64_t
2377isp_get_portname(ispsoftc_t *isp, int loopid, int nodename)
2378{
2379 uint64_t wwn = (uint64_t) -1;
2380 mbreg_t mbs;
2381
2382 MEMZERO(&mbs, sizeof (mbs));
2383 mbs.param[0] = MBOX_GET_PORT_NAME;
2384 if (FCPARAM(isp)->isp_2klogin || IS_24XX(isp)) {
2385 mbs.param[1] = loopid;
2386 mbs.ibits = (1 << 10);
2387 if (nodename) {
2388 mbs.param[10] = 1;
2389 }
2390 } else {
2391 mbs.param[1] = loopid << 8;
2392 if (nodename) {
2393 mbs.param[1] |= 1;
2394 }
2395 }
2396 mbs.logval = MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR;
2397 isp_mboxcmd(isp, &mbs);
2398 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2399 return (wwn);
2400 }
2401 if (IS_24XX(isp)) {
2402 wwn =
2403 (((uint64_t)(mbs.param[2] >> 8)) << 56) |
2404 (((uint64_t)(mbs.param[2] & 0xff)) << 48) |
2405 (((uint64_t)(mbs.param[3] >> 8)) << 40) |
2406 (((uint64_t)(mbs.param[3] & 0xff)) << 32) |
2407 (((uint64_t)(mbs.param[6] >> 8)) << 24) |
2408 (((uint64_t)(mbs.param[6] & 0xff)) << 16) |
2409 (((uint64_t)(mbs.param[7] >> 8)) << 8) |
2410 (((uint64_t)(mbs.param[7] & 0xff)));
2411 } else {
2412 wwn =
2413 (((uint64_t)(mbs.param[2] & 0xff)) << 56) |
2414 (((uint64_t)(mbs.param[2] >> 8)) << 48) |
2415 (((uint64_t)(mbs.param[3] & 0xff)) << 40) |
2416 (((uint64_t)(mbs.param[3] >> 8)) << 32) |
2417 (((uint64_t)(mbs.param[6] & 0xff)) << 24) |
2418 (((uint64_t)(mbs.param[6] >> 8)) << 16) |
2419 (((uint64_t)(mbs.param[7] & 0xff)) << 8) |
2420 (((uint64_t)(mbs.param[7] >> 8)));
2421 }
2422 return (wwn);
2423}
2424
2425/*
2426 * Make sure we have good FC link.
2427 */
2428
2429static int
2430isp_fclink_test(ispsoftc_t *isp, int usdelay)
2431{
2432 static const char *toponames[] = {
2433 "Private Loop",
2434 "FL Port",
2435 "N-Port to N-Port",
2436 "F Port",
2437 "F Port (no FLOGI_ACC response)"
2438 };
2439 mbreg_t mbs;
2440 int count, check_for_fabric;
2441 uint8_t lwfs;
2442 int loopid;
2443 fcparam *fcp;
2444 fcportdb_t *lp;
2445 isp_pdb_t pdb;
2446
2447 fcp = isp->isp_param;
2448
2449 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Link Test Entry");
2450 ISP_MARK_PORTDB(isp, 1);
2451
2452 /*
2453 * Wait up to N microseconds for F/W to go to a ready state.
2454 */
2455 lwfs = FW_CONFIG_WAIT;
2456 count = 0;
2457 while (count < usdelay) {
2458 uint64_t enano;
2459 uint32_t wrk;
2460 NANOTIME_T hra, hrb;
2461
2462 GET_NANOTIME(&hra);
2463 isp_fw_state(isp);
2464 if (lwfs != fcp->isp_fwstate) {
2465 isp_prt(isp, ISP_LOGCONFIG|ISP_LOGSANCFG,
2466 "Firmware State <%s->%s>",
2467 ispfc_fw_statename((int)lwfs),
2468 ispfc_fw_statename((int)fcp->isp_fwstate));
2469 lwfs = fcp->isp_fwstate;
2470 }
2471 if (fcp->isp_fwstate == FW_READY) {
2472 break;
2473 }
2474 GET_NANOTIME(&hrb);
2475
2476 /*
2477 * Get the elapsed time in nanoseconds.
2478 * Always guaranteed to be non-zero.
2479 */
2480 enano = NANOTIME_SUB(&hrb, &hra);
2481
2482 isp_prt(isp, ISP_LOGDEBUG1,
2483 "usec%d: 0x%lx->0x%lx enano 0x%x%08x",
2484 count, (long) GET_NANOSEC(&hra), (long) GET_NANOSEC(&hrb),
2485 (uint32_t)(enano >> 32), (uint32_t)(enano & 0xffffffff));
2486
2487 /*
2488 * If the elapsed time is less than 1 millisecond,
2489 * delay a period of time up to that millisecond of
2490 * waiting.
2491 *
2492 * This peculiar code is an attempt to try and avoid
2493 * invoking uint64_t math support functions for some
2494 * platforms where linkage is a problem.
2495 */
2496 if (enano < (1000 * 1000)) {
2497 count += 1000;
2498 enano = (1000 * 1000) - enano;
2499 while (enano > (uint64_t) 4000000000U) {
2500 USEC_SLEEP(isp, 4000000);
2501 enano -= (uint64_t) 4000000000U;
2502 }
2503 wrk = enano;
2504 wrk /= 1000;
2505 USEC_SLEEP(isp, wrk);
2506 } else {
2507 while (enano > (uint64_t) 4000000000U) {
2508 count += 4000000;
2509 enano -= (uint64_t) 4000000000U;
2510 }
2511 wrk = enano;
2512 count += (wrk / 1000);
2513 }
2514 }
2515
2516 /*
2517 * If we haven't gone to 'ready' state, return.
2518 */
2519 if (fcp->isp_fwstate != FW_READY) {
2520 isp_prt(isp, ISP_LOGSANCFG,
2521 "isp_fclink_test: not at FW_READY state");
2522 return (-1);
2523 }
2524
2525 /*
2526 * Get our Loop ID and Port ID.
2527 */
2528 MEMZERO(&mbs, sizeof (mbs));
2529 mbs.param[0] = MBOX_GET_LOOP_ID;
2530 mbs.logval = MBLOGALL;
2531 isp_mboxcmd(isp, &mbs);
2532 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2533 return (-1);
2534 }
2535
2536 if (FCPARAM(isp)->isp_2klogin) {
2537 fcp->isp_loopid = mbs.param[1];
2538 } else {
2539 fcp->isp_loopid = mbs.param[1] & 0xff;
2540 }
2541
2542 if (IS_2100(isp)) {
2543 fcp->isp_topo = TOPO_NL_PORT;
2544 } else {
2545 int topo = (int) mbs.param[6];
2546 if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB) {
2547 topo = TOPO_PTP_STUB;
2548 }
2549 fcp->isp_topo = topo;
2550 }
2551 fcp->isp_portid = mbs.param[2] | (mbs.param[3] << 16);
2552
2553 if (IS_2100(isp)) {
2554 /*
2555 * Don't bother with fabric if we are using really old
2556 * 2100 firmware. It's just not worth it.
2557 */
2558 if (ISP_FW_NEWER_THAN(isp, 1, 15, 37)) {
2559 check_for_fabric = 1;
2560 } else {
2561 check_for_fabric = 0;
2562 }
2563 } else if (fcp->isp_topo == TOPO_FL_PORT ||
2564 fcp->isp_topo == TOPO_F_PORT) {
2565 check_for_fabric = 1;
2566 } else {
2567 check_for_fabric = 0;
2568 }
2569
2570 if (IS_24XX(isp)) {
2571 loopid = NPH_FL_ID;
2572 } else {
2573 loopid = FL_ID;
2574 }
2575
2576 if (check_for_fabric && isp_getpdb(isp, loopid, &pdb, 1) == 0) {
2577 int r;
2578 if (IS_2100(isp)) {
2579 fcp->isp_topo = TOPO_FL_PORT;
2580 }
2581 if (pdb.portid == 0) {
2582 /*
2583 * Crock.
2584 */
2585 fcp->isp_topo = TOPO_NL_PORT;
2586 goto not_on_fabric;
2587 }
2588
2589 /*
2590 * Save the Fabric controller's port database entry.
2591 */
2592 lp = &fcp->portdb[FL_ID];
2593 lp->state = FC_PORTDB_STATE_PENDING_VALID;
2594 MAKE_WWN_FROM_NODE_NAME(lp->node_wwn, pdb.nodename);
2595 MAKE_WWN_FROM_NODE_NAME(lp->port_wwn, pdb.portname);
2596 lp->roles = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2597 lp->portid = pdb.portid;
2598 lp->handle = pdb.handle;
2599 lp->new_portid = lp->portid;
2600 lp->new_roles = lp->roles;
2601 if (IS_24XX(isp)) {
2602 r = isp_register_fc4_type_24xx(isp);
2603 } else {
2604 r = isp_register_fc4_type(isp);
2605 }
2606 if (r) {
2607 isp_prt(isp, ISP_LOGSANCFG,
2608 "isp_fclink_test: register fc4 type failed");
2609 return (-1);
2610 }
2611 } else {
2612not_on_fabric:
2613 fcp->portdb[FL_ID].state = FC_PORTDB_STATE_NIL;
2614 }
2615
2616 fcp->isp_gbspeed = 1;
2617 if (IS_23XX(isp) || IS_24XX(isp)) {
2618 MEMZERO(&mbs, sizeof (mbs));
2619 mbs.param[0] = MBOX_GET_SET_DATA_RATE;
2620 mbs.param[1] = MBGSD_GET_RATE;
2621 /* mbs.param[2] undefined if we're just getting rate */
2622 mbs.logval = MBLOGALL;
2623 mbs.timeout = 3000000;
2624 isp_mboxcmd(isp, &mbs);
2625 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
2626 if (mbs.param[1] == MBGSD_FOURGB) {
2627 isp_prt(isp, ISP_LOGINFO, "4Gb link speed/s");
2628 fcp->isp_gbspeed = 4;
2629 } if (mbs.param[1] == MBGSD_TWOGB) {
2630 isp_prt(isp, ISP_LOGINFO, "2Gb link speed/s");
2631 fcp->isp_gbspeed = 2;
2632 }
2633 }
2634 }
2635
2636 /*
2637 * Announce ourselves, too.
2638 */
2639 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGCONFIG, topology, fcp->isp_portid,
2640 fcp->isp_loopid, toponames[fcp->isp_topo]);
2641 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGCONFIG, ourwwn,
2642 (uint32_t) (ISP_NODEWWN(isp) >> 32),
2643 (uint32_t) ISP_NODEWWN(isp),
2644 (uint32_t) (ISP_PORTWWN(isp) >> 32),
2645 (uint32_t) ISP_PORTWWN(isp));
2646 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Link Test Complete");
2647 return (0);
2648}
2649
2650static const char *
2651ispfc_fw_statename(int state)
2652{
2653 switch(state) {
2654 case FW_CONFIG_WAIT: return "Config Wait";
2655 case FW_WAIT_AL_PA: return "Waiting for AL_PA";
2656 case FW_WAIT_LOGIN: return "Wait Login";
2657 case FW_READY: return "Ready";
2658 case FW_LOSS_OF_SYNC: return "Loss Of Sync";
2659 case FW_ERROR: return "Error";
2660 case FW_REINIT: return "Re-Init";
2661 case FW_NON_PART: return "Nonparticipating";
2662 default: return "?????";
2663 }
2664}
2665
2666/*
2667 * Complete the synchronization of our Port Database.
2668 *
2669 * At this point, we've scanned the local loop (if any) and the fabric
2670 * and performed fabric logins on all new devices.
2671 *
2672 * Our task here is to go through our port database and remove any entities
2673 * that are still marked probational (issuing PLOGO for ones which we had
2674 * PLOGI'd into) or are dead.
2675 *
2676 * Our task here is to also check policy to decide whether devices which
2677 * have *changed* in some way should still be kept active. For example,
2678 * if a device has just changed PortID, we can either elect to treat it
2679 * as an old device or as a newly arrived device (and notify the outer
2680 * layer appropriately).
2681 *
2682 * We also do initiator map target id assignment here for new initiator
2683 * devices and refresh old ones ot make sure that they point to the corret
2684 * entities.
2685 */
2686static int
2687isp_pdb_sync(ispsoftc_t *isp)
2688{
2689 fcparam *fcp = isp->isp_param;
2690 fcportdb_t *lp;
2691 uint16_t dbidx;
2692
2693 if (fcp->isp_loopstate == LOOP_READY) {
2694 return (0);
2695 }
2696
2697 /*
2698 * Make sure we're okay for doing this right now.
2699 */
2700 if (fcp->isp_loopstate != LOOP_PDB_RCVD &&
2701 fcp->isp_loopstate != LOOP_FSCAN_DONE &&
2702 fcp->isp_loopstate != LOOP_LSCAN_DONE) {
2703 isp_prt(isp, ISP_LOGWARN, "isp_pdb_sync: bad loopstate %d",
2704 fcp->isp_loopstate);
2705 return (-1);
2706 }
2707
2708 if (fcp->isp_topo == TOPO_FL_PORT ||
2709 fcp->isp_topo == TOPO_NL_PORT ||
2710 fcp->isp_topo == TOPO_N_PORT) {
2711 if (fcp->isp_loopstate < LOOP_LSCAN_DONE) {
2712 if (isp_scan_loop(isp) != 0) {
2713 isp_prt(isp, ISP_LOGWARN,
2714 "isp_pdb_sync: isp_scan_loop failed");
2715 return (-1);
2716 }
2717 }
2718 }
2719
2720 if (fcp->isp_topo == TOPO_F_PORT || fcp->isp_topo == TOPO_FL_PORT) {
2721 if (fcp->isp_loopstate < LOOP_FSCAN_DONE) {
2722 if (isp_scan_fabric(isp) != 0) {
2723 isp_prt(isp, ISP_LOGWARN,
2724 "isp_pdb_sync: isp_scan_fabric failed");
2725 return (-1);
2726 }
2727 }
2728 }
2729
2730 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Synchronizing PDBs");
2731
2732 fcp->isp_loopstate = LOOP_SYNCING_PDB;
2733
2734 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
2735 lp = &fcp->portdb[dbidx];
2736
2737 if (lp->state == FC_PORTDB_STATE_NIL) {
2738 continue;
2739 }
2740
2741 if (lp->state == FC_PORTDB_STATE_VALID) {
2742 if (dbidx != FL_ID) {
2743 isp_prt(isp,
2744 ISP_LOGERR, "portdb idx %d already valid",
2745 dbidx);
2746 }
2747 continue;
2748 }
2749
2750 switch (lp->state) {
2751 case FC_PORTDB_STATE_PROBATIONAL:
2752 case FC_PORTDB_STATE_DEAD:
2753 /*
2754 * It's up to the outer layers to clear isp_ini_map.
2755 */
2756 lp->state = FC_PORTDB_STATE_NIL;
2757 isp_async(isp, ISPASYNC_DEV_GONE, lp);
2758 if (lp->autologin == 0) {
2759 (void) isp_plogx(isp, lp->handle, lp->portid,
2760 PLOGX_FLG_CMD_LOGO |
2761 PLOGX_FLG_IMPLICIT |
2762 PLOGX_FLG_FREE_NPHDL, 0);
2763 } else {
2764 lp->autologin = 0;
2765 }
2766 lp->new_roles = 0;
2767 lp->new_portid = 0;
2768 /*
2769 * Note that we might come out of this with our state
2770 * set to FC_PORTDB_STATE_ZOMBIE.
2771 */
2772 break;
2773 case FC_PORTDB_STATE_NEW:
2774 /*
2775 * It's up to the outer layers to assign a virtual
2776 * target id in isp_ini_map (if any).
2777 */
2778 lp->portid = lp->new_portid;
2779 lp->roles = lp->new_roles;
2780 lp->state = FC_PORTDB_STATE_VALID;
2781 isp_async(isp, ISPASYNC_DEV_ARRIVED, lp);
2782 lp->new_roles = 0;
2783 lp->new_portid = 0;
2784 lp->reserved = 0;
2785 lp->new_reserved = 0;
2786 break;
2787 case FC_PORTDB_STATE_CHANGED:
2788/*
2789 * XXXX FIX THIS
2790 */
2791 lp->state = FC_PORTDB_STATE_VALID;
2792 isp_async(isp, ISPASYNC_DEV_CHANGED, lp);
2793 lp->new_roles = 0;
2794 lp->new_portid = 0;
2795 lp->reserved = 0;
2796 lp->new_reserved = 0;
2797 break;
2798 case FC_PORTDB_STATE_PENDING_VALID:
2799 lp->portid = lp->new_portid;
2800 lp->roles = lp->new_roles;
2801 if (lp->ini_map_idx) {
2802 int t = lp->ini_map_idx - 1;
2803 fcp->isp_ini_map[t] = dbidx + 1;
2804 }
2805 lp->state = FC_PORTDB_STATE_VALID;
2806 isp_async(isp, ISPASYNC_DEV_STAYED, lp);
2807 if (dbidx != FL_ID) {
2808 lp->new_roles = 0;
2809 lp->new_portid = 0;
2810 }
2811 lp->reserved = 0;
2812 lp->new_reserved = 0;
2813 break;
2814 case FC_PORTDB_STATE_ZOMBIE:
2815 break;
2816 default:
2817 isp_prt(isp, ISP_LOGWARN,
2818 "isp_scan_loop: state %d for idx %d",
2819 lp->state, dbidx);
2820 isp_dump_portdb(isp);
2821 }
2822 }
2823
2824 /*
2825 * If we get here, we've for sure seen not only a valid loop
2826 * but know what is or isn't on it, so mark this for usage
2827 * in isp_start.
2828 */
2829 fcp->loop_seen_once = 1;
2830 fcp->isp_loopstate = LOOP_READY;
2831 return (0);
2832}
2833
2834/*
2835 * Scan local loop for devices.
2836 */
2837static int
2838isp_scan_loop(ispsoftc_t *isp)
2839{
2840 fcportdb_t *lp, tmp;
2841 fcparam *fcp = isp->isp_param;
2842 int i;
2843 isp_pdb_t pdb;
2844 uint16_t handle, lim = 0;
2845
2846 if (fcp->isp_fwstate < FW_READY ||
2847 fcp->isp_loopstate < LOOP_PDB_RCVD) {
2848 return (-1);
2849 }
2850
2851 if (fcp->isp_loopstate > LOOP_SCANNING_LOOP) {
2852 return (0);
2853 }
2854
2855 /*
2856 * Check our connection topology.
2857 *
2858 * If we're a public or private loop, we scan 0..125 as handle values.
2859 * The firmware has (typically) peformed a PLOGI for us.
2860 *
2861 * If we're a N-port connection, we treat this is a short loop (0..1).
2862 *
2863 * If we're in target mode, we can all possible handles to see who
2864 * might have logged into us.
2865 */
2866 switch (fcp->isp_topo) {
2867 case TOPO_NL_PORT:
2868 case TOPO_FL_PORT:
2869 lim = LOCAL_LOOP_LIM;
2870 break;
2871 case TOPO_N_PORT:
2872 lim = 2;
2873 break;
2874 default:
2875 isp_prt(isp, ISP_LOGDEBUG0, "no loop topology to scan");
2876 fcp->isp_loopstate = LOOP_LSCAN_DONE;
2877 return (0);
2878 }
2879
2880 fcp->isp_loopstate = LOOP_SCANNING_LOOP;
2881
2882 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC scan loop 0..%d", lim-1);
2883
2884
2885 /*
2886 * Run through the list and get the port database info for each one.
2887 */
2888 for (handle = 0; handle < lim; handle++) {
2889 /*
2890 * But don't even try for ourselves...
2891 */
2892 if (handle == fcp->isp_loopid) {
2893 continue;
2894 }
2895
2896 /*
2897 * In older cards with older f/w GET_PORT_DATABASE has been
2898 * known to hang. This trick gets around that problem.
2899 */
2900 if (IS_2100(isp) || IS_2200(isp)) {
2901 uint64_t node_wwn = isp_get_portname(isp, handle, 1);
2902 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2903 return (-1);
2904 }
2905 if (node_wwn == 0) {
2906 continue;
2907 }
2908 }
2909
2910 /*
2911 * Get the port database entity for this index.
2912 */
2913 if (isp_getpdb(isp, handle, &pdb, 1) != 0) {
2914 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2915 ISP_MARK_PORTDB(isp, 1);
2916 return (-1);
2917 }
2918 continue;
2919 }
2920
2921 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2922 ISP_MARK_PORTDB(isp, 1);
2923 return (-1);
2924 }
2925
2926 /*
2927 * On *very* old 2100 firmware we would end up sometimes
2928 * with the firmware returning the port database entry
2929 * for something else. We used to restart this, but
2930 * now we just punt.
2931 */
2932 if (IS_2100(isp) && pdb.handle != handle) {
2933 isp_prt(isp, ISP_LOGWARN,
2934 "giving up on synchronizing the port database");
2935 ISP_MARK_PORTDB(isp, 1);
2936 return (-1);
2937 }
2938
2939 /*
2940 * Save the pertinent info locally.
2941 */
2942 MAKE_WWN_FROM_NODE_NAME(tmp.node_wwn, pdb.nodename);
2943 MAKE_WWN_FROM_NODE_NAME(tmp.port_wwn, pdb.portname);
2944 tmp.roles = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2945 tmp.portid = pdb.portid;
2946 tmp.handle = pdb.handle;
2947
2948 /*
2949 * Check to make sure it's still a valid entry. The 24XX seems
2950 * to return a portid but not a WWPN/WWNN or role for devices
|
2966 * which shift on a loop, or have a WWPN/WWNN but no portid.
| 2951 * which shift on a loop.
|
2967 */
2968 if (tmp.node_wwn == 0 || tmp.port_wwn == 0 || tmp.portid == 0) {
| 2952 */
2953 if (tmp.node_wwn == 0 || tmp.port_wwn == 0 || tmp.portid == 0) {
|
2969 if (isp->isp_dblev & ISP_LOGSANCFG) {
2970 int a, b, c;
2971 a = !(tmp.node_wwn == 0);
2972 b = !(tmp.port_wwn == 0);
2973 c = !(tmp.portid == 0);
2974 isp_prt(isp, ISP_LOGALL,
2975 "bad pdb (%1d%1d%1d) @ handle 0x%x",
2976 a, b, c, handle);
2977 isp_dump_portdb(isp);
2978 }
| 2954 int a, b, c;
2955 a = (tmp.node_wwn == 0);
2956 b = (tmp.port_wwn == 0);
2957 c = (tmp.portid == 0);
2958 isp_prt(isp, ISP_LOGWARN,
2959 "bad pdb (%1d%1d%1d) @ handle 0x%x", a, b, c,
2960 handle);
2961 isp_dump_portdb(isp);
|
2979 continue;
2980 }
2981
2982 /*
2983 * Now search the entire port database
2984 * for the same Port and Node WWN.
2985 */
2986 for (i = 0; i < MAX_FC_TARG; i++) {
2987 lp = &fcp->portdb[i];
2988 if (lp->state == FC_PORTDB_STATE_NIL) {
2989 continue;
2990 }
2991 if (lp->node_wwn != tmp.node_wwn) {
2992 continue;
2993 }
2994 if (lp->port_wwn != tmp.port_wwn) {
2995 continue;
2996 }
2997
2998 /*
2999 * Okay- we've found a non-nil entry that matches.
3000 * Check to make sure it's probational or a zombie.
3001 */
3002 if (lp->state != FC_PORTDB_STATE_PROBATIONAL &&
3003 lp->state != FC_PORTDB_STATE_ZOMBIE) {
3004 isp_prt(isp, ISP_LOGERR,
3005 "[%d] not probational/zombie (0x%x)",
3006 i, lp->state);
3007 isp_dump_portdb(isp);
3008 ISP_MARK_PORTDB(isp, 1);
3009 return (-1);
3010 }
3011
3012 /*
3013 * Mark the device as something the f/w logs into
3014 * automatically.
3015 */
3016 lp->autologin = 1;
3017
3018 /*
3019 * Check to make see if really still the same
3020 * device. If it is, we mark it pending valid.
3021 */
3022 if (lp->portid == tmp.portid &&
3023 lp->handle == tmp.handle &&
3024 lp->roles == tmp.roles) {
3025 lp->new_portid = tmp.portid;
3026 lp->new_roles = tmp.roles;
3027 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3028 isp_prt(isp, ISP_LOGSANCFG,
3029 "Loop Port 0x%02x@0x%x Pending Valid",
3030 tmp.portid, tmp.handle);
3031 break;
3032 }
3033
3034 /*
3035 * We can wipe out the old handle value
3036 * here because it's no longer valid.
3037 */
3038 lp->handle = tmp.handle;
3039
3040 /*
3041 * Claim that this has changed and let somebody else
3042 * decide what to do.
3043 */
3044 isp_prt(isp, ISP_LOGSANCFG,
3045 "Loop Port 0x%02x@0x%x changed",
3046 tmp.portid, tmp.handle);
3047 lp->state = FC_PORTDB_STATE_CHANGED;
3048 lp->new_portid = tmp.portid;
3049 lp->new_roles = tmp.roles;
3050 break;
3051 }
3052
3053 /*
3054 * Did we find and update an old entry?
3055 */
3056 if (i < MAX_FC_TARG) {
3057 continue;
3058 }
3059
3060 /*
3061 * Ah. A new device entry. Find an empty slot
3062 * for it and save info for later disposition.
3063 */
3064 for (i = 0; i < MAX_FC_TARG; i++) {
3065 if (fcp->portdb[i].state == FC_PORTDB_STATE_NIL) {
3066 break;
3067 }
3068 }
3069 if (i == MAX_FC_TARG) {
3070 isp_prt(isp, ISP_LOGERR, "out of portdb entries");
3071 continue;
3072 }
3073 lp = &fcp->portdb[i];
3074
3075 MEMZERO(lp, sizeof (fcportdb_t));
3076 lp->autologin = 1;
3077 lp->state = FC_PORTDB_STATE_NEW;
3078 lp->new_portid = tmp.portid;
3079 lp->new_roles = tmp.roles;
3080 lp->handle = tmp.handle;
3081 lp->port_wwn = tmp.port_wwn;
3082 lp->node_wwn = tmp.node_wwn;
3083 isp_prt(isp, ISP_LOGSANCFG,
3084 "Loop Port 0x%02x@0x%x is New Entry",
3085 tmp.portid, tmp.handle);
3086 }
3087 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3088 return (0);
3089}
3090
3091/*
3092 * Scan the fabric for devices and add them to our port database.
3093 *
3094 * Use the GID_FT command to get all Port IDs for FC4 SCSI devices it knows.
3095 *
3096 * For 2100-23XX cards, we can use the SNS mailbox command to pass simple
3097 * name server commands to the switch management server via the QLogic f/w.
3098 *
3099 * For the 24XX card, we have to use CT-Pass through run via the Execute IOCB
3100 * mailbox command.
3101 *
3102 * The net result is to leave the list of Port IDs setting untranslated in
3103 * offset IGPOFF of the FC scratch area, whereupon we'll canonicalize it to
3104 * host order at OGPOFF.
3105 */
3106
3107/*
3108 * Take less than half of our scratch area to store Port IDs
3109 */
3110#define GIDLEN ((ISP2100_SCRLEN >> 1) - 16 - SNS_GID_FT_REQ_SIZE)
3111#define NGENT ((GIDLEN - 16) >> 2)
3112
3113#define IGPOFF (2 * QENTRY_LEN)
3114#define OGPOFF (ISP2100_SCRLEN >> 1)
3115#define ZTXOFF (ISP2100_SCRLEN - (1 * QENTRY_LEN))
3116#define CTXOFF (ISP2100_SCRLEN - (2 * QENTRY_LEN))
3117#define XTXOFF (ISP2100_SCRLEN - (3 * QENTRY_LEN))
3118
3119static int
3120isp_gid_ft_sns(ispsoftc_t *isp)
3121{
3122 union {
3123 sns_gid_ft_req_t _x;
3124 uint8_t _y[SNS_GID_FT_REQ_SIZE];
3125 } un;
3126 fcparam *fcp = FCPARAM(isp);
3127 sns_gid_ft_req_t *rq = &un._x;
3128 mbreg_t mbs;
3129
3130 isp_prt(isp, ISP_LOGDEBUG0, "scanning fabric (GID_FT) via SNS");
3131
3132 MEMZERO(rq, SNS_GID_FT_REQ_SIZE);
3133 rq->snscb_rblen = GIDLEN >> 1;
3134 rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + IGPOFF);
3135 rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + IGPOFF);
3136 rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + IGPOFF);
3137 rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + IGPOFF);
3138 rq->snscb_sblen = 6;
3139 rq->snscb_cmd = SNS_GID_FT;
3140 rq->snscb_mword_div_2 = NGENT;
3141 rq->snscb_fc4_type = FC4_SCSI;
3142
3143 isp_put_gid_ft_request(isp, rq, fcp->isp_scratch);
3144 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GID_FT_REQ_SIZE);
3145
3146 MEMZERO(&mbs, sizeof (mbs));
3147 mbs.param[0] = MBOX_SEND_SNS;
3148 mbs.param[1] = SNS_GID_FT_REQ_SIZE >> 1;
3149 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
3150 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
3151 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
3152 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
3153 mbs.logval = MBLOGALL;
3154 mbs.timeout = 10000000;
3155 isp_mboxcmd(isp, &mbs);
3156 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3157 if (mbs.param[0] == MBOX_INVALID_COMMAND) {
3158 return (1);
3159 } else {
3160 return (-1);
3161 }
3162 }
3163 return (0);
3164}
3165
3166static int
3167isp_gid_ft_ct_passthru(ispsoftc_t *isp)
3168{
3169 mbreg_t mbs;
3170 fcparam *fcp = FCPARAM(isp);
3171 union {
3172 isp_ct_pt_t plocal;
3173 ct_hdr_t clocal;
3174 uint8_t q[QENTRY_LEN];
3175 } un;
3176 isp_ct_pt_t *pt;
3177 ct_hdr_t *ct;
3178 uint32_t *rp;
3179 uint8_t *scp = fcp->isp_scratch;
3180
3181 isp_prt(isp, ISP_LOGDEBUG0, "scanning fabric (GID_FT) via CT");
3182
3183 if (!IS_24XX(isp)) {
3184 return (1);
3185 }
3186
3187 /*
3188 * Build a Passthrough IOCB in memory.
3189 */
3190 pt = &un.plocal;
3191 MEMZERO(un.q, QENTRY_LEN);
3192 pt->ctp_header.rqs_entry_count = 1;
3193 pt->ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
3194 pt->ctp_handle = 0xffffffff;
3195 pt->ctp_nphdl = NPH_SNS_ID;
3196 pt->ctp_cmd_cnt = 1;
3197 pt->ctp_time = 30;
3198 pt->ctp_rsp_cnt = 1;
3199 pt->ctp_rsp_bcnt = GIDLEN;
3200 pt->ctp_cmd_bcnt = sizeof (*ct) + sizeof (uint32_t);
3201 pt->ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma+XTXOFF);
3202 pt->ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma+XTXOFF);
3203 pt->ctp_dataseg[0].ds_count = sizeof (*ct) + sizeof (uint32_t);
3204 pt->ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma+IGPOFF);
3205 pt->ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma+IGPOFF);
3206 pt->ctp_dataseg[1].ds_count = GIDLEN;
3207 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3208 isp_print_bytes(isp, "ct IOCB", QENTRY_LEN, pt);
3209 }
3210 isp_put_ct_pt(isp, pt, (isp_ct_pt_t *) &scp[CTXOFF]);
3211
3212 /*
3213 * Build the CT header and command in memory.
3214 *
3215 * Note that the CT header has to end up as Big Endian format in memory.
3216 */
3217 ct = &un.clocal;
3218 MEMZERO(ct, sizeof (*ct));
3219 ct->ct_revision = CT_REVISION;
3220 ct->ct_fcs_type = CT_FC_TYPE_FC;
3221 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3222 ct->ct_cmd_resp = SNS_GID_FT;
3223 ct->ct_bcnt_resid = (GIDLEN - 16) >> 2;
3224
3225 isp_put_ct_hdr(isp, ct, (ct_hdr_t *) &scp[XTXOFF]);
3226 rp = (uint32_t *) &scp[XTXOFF+sizeof (*ct)];
3227 ISP_IOZPUT_32(isp, FC4_SCSI, rp);
3228 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3229 isp_print_bytes(isp, "CT HDR + payload after put",
3230 sizeof (*ct) + sizeof (uint32_t), &scp[XTXOFF]);
3231 }
3232 MEMZERO(&scp[ZTXOFF], QENTRY_LEN);
3233 MEMZERO(&mbs, sizeof (mbs));
3234 mbs.param[0] = MBOX_EXEC_COMMAND_IOCB_A64;
3235 mbs.param[1] = QENTRY_LEN;
3236 mbs.param[2] = DMA_WD1(fcp->isp_scdma + CTXOFF);
3237 mbs.param[3] = DMA_WD0(fcp->isp_scdma + CTXOFF);
3238 mbs.param[6] = DMA_WD3(fcp->isp_scdma + CTXOFF);
3239 mbs.param[7] = DMA_WD2(fcp->isp_scdma + CTXOFF);
3240 mbs.timeout = 500000;
3241 mbs.logval = MBLOGALL;
3242 MEMORYBARRIER(isp, SYNC_SFORDEV, XTXOFF, 2 * QENTRY_LEN);
3243 isp_mboxcmd(isp, &mbs);
3244 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3245 return (-1);
3246 }
3247 MEMORYBARRIER(isp, SYNC_SFORCPU, ZTXOFF, QENTRY_LEN);
3248 pt = &un.plocal;
3249 isp_get_ct_pt(isp, (isp_ct_pt_t *) &scp[ZTXOFF], pt);
3250 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3251 isp_print_bytes(isp, "IOCB response", QENTRY_LEN, pt);
3252 }
3253
3254 if (pt->ctp_status && pt->ctp_status != RQCS_DATA_UNDERRUN) {
3255 isp_prt(isp, ISP_LOGWARN, "CT Passthrough returned 0x%x",
3256 pt->ctp_status);
3257 return (-1);
3258 }
3259 MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN + 16);
3260 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3261 isp_print_bytes(isp, "CT response", GIDLEN+16, &scp[IGPOFF]);
3262 }
3263 return (0);
3264}
3265
3266static int
3267isp_scan_fabric(ispsoftc_t *isp)
3268{
3269 fcparam *fcp = FCPARAM(isp);
3270 uint32_t portid;
3271 uint16_t handle, oldhandle;
3272 int portidx, portlim, r;
3273 sns_gid_ft_rsp_t *rs0, *rs1;
3274
3275 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Scan Fabric");
3276 if (fcp->isp_fwstate != FW_READY ||
3277 fcp->isp_loopstate < LOOP_LSCAN_DONE) {
3278 return (-1);
3279 }
3280 if (fcp->isp_loopstate > LOOP_SCANNING_FABRIC) {
3281 return (0);
3282 }
3283 if (fcp->isp_topo != TOPO_FL_PORT && fcp->isp_topo != TOPO_F_PORT) {
3284 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3285 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3286 "FC Scan Fabric Done (no fabric)");
3287 return (0);
3288 }
3289
3290 FC_SCRATCH_ACQUIRE(isp);
3291 fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
3292
3293 if (IS_24XX(isp)) {
3294 r = isp_gid_ft_ct_passthru(isp);
3295 } else {
3296 r = isp_gid_ft_sns(isp);
3297 }
3298
3299 if (r > 0) {
3300 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3301 FC_SCRATCH_RELEASE(isp);
3302 return (0);
3303 } else if (r < 0) {
3304 fcp->isp_loopstate = LOOP_PDB_RCVD; /* try again */
3305 FC_SCRATCH_RELEASE(isp);
3306 return (0);
3307 }
3308 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3309 FC_SCRATCH_RELEASE(isp);
3310 return (-1);
3311 }
3312
3313 MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN);
3314 rs0 = (sns_gid_ft_rsp_t *) ((uint8_t *)fcp->isp_scratch+IGPOFF);
3315 rs1 = (sns_gid_ft_rsp_t *) ((uint8_t *)fcp->isp_scratch+OGPOFF);
3316 isp_get_gid_ft_response(isp, rs0, rs1, NGENT);
3317 if (rs1->snscb_cthdr.ct_cmd_resp != LS_ACC) {
3318 int level;
3319 if (rs1->snscb_cthdr.ct_reason == 9 &&
3320 rs1->snscb_cthdr.ct_explanation == 7) {
3321 level = ISP_LOGSANCFG|ISP_LOGDEBUG0;
3322 } else {
3323 level = ISP_LOGWARN;
3324 }
3325 isp_prt(isp, level, "Fabric Nameserver rejected GID_FT "
3326 "(Reason=0x%x Expl=0x%x)", rs1->snscb_cthdr.ct_reason,
3327 rs1->snscb_cthdr.ct_explanation);
3328 FC_SCRATCH_RELEASE(isp);
3329 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3330 return (0);
3331 }
3332
3333
3334 /*
3335 * If we get this far, we certainly still have the fabric controller.
3336 */
3337 fcp->portdb[FL_ID].state = FC_PORTDB_STATE_PENDING_VALID;
3338
3339 /*
3340 * Prime the handle we will start using.
3341 */
3342 oldhandle = NIL_HANDLE;
3343
3344 /*
3345 * Okay, we now have a list of Port IDs for all FC4 SCSI devices
3346 * that the Fabric Name server knows about. Go through the list
3347 * and remove duplicate port ids.
3348 */
3349
3350 portlim = 0;
3351 portidx = 0;
3352 for (portidx = 0; portidx < NGENT-1; portidx++) {
3353 if (rs1->snscb_ports[portidx].control & 0x80) {
3354 break;
3355 }
3356 }
3357
3358 /*
3359 * If we're not at the last entry, our list wasn't big enough.
3360 */
3361 if ((rs1->snscb_ports[portidx].control & 0x80) == 0) {
3362 isp_prt(isp, ISP_LOGWARN,
3363 "fabric too big for scratch area: increase ISP2100_SCRLEN");
3364 }
3365 portlim = portidx + 1;
3366 isp_prt(isp, ISP_LOGSANCFG,
3367 "got %d ports back from name server", portlim);
3368
3369 for (portidx = 0; portidx < portlim; portidx++) {
3370 int npidx;
3371
3372 portid =
3373 ((rs1->snscb_ports[portidx].portid[0]) << 16) |
3374 ((rs1->snscb_ports[portidx].portid[1]) << 8) |
3375 ((rs1->snscb_ports[portidx].portid[2]));
3376
3377 for (npidx = portidx + 1; npidx < portlim; npidx++) {
3378 uint32_t new_portid =
3379 ((rs1->snscb_ports[npidx].portid[0]) << 16) |
3380 ((rs1->snscb_ports[npidx].portid[1]) << 8) |
3381 ((rs1->snscb_ports[npidx].portid[2]));
3382 if (new_portid == portid) {
3383 break;
3384 }
3385 }
3386
3387 if (npidx < portlim) {
3388 rs1->snscb_ports[npidx].portid[0] = 0;
3389 rs1->snscb_ports[npidx].portid[1] = 0;
3390 rs1->snscb_ports[npidx].portid[2] = 0;
3391 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3392 "removing duplicate PortID 0x%x entry from list",
3393 portid);
3394 }
3395 }
3396
3397 /*
3398 * Okay, we now have a list of Port IDs for all FC4 SCSI devices
3399 * that the Fabric Name server knows about.
3400 *
3401 * For each entry on this list go through our port database looking
3402 * for probational entries- if we find one, then an old entry is
3403 * is maybe still this one. We get some information to find out.
3404 *
3405 * Otherwise, it's a new fabric device, and we log into it
3406 * (unconditionally). After searching the entire database
3407 * again to make sure that we never ever ever ever have more
3408 * than one entry that has the same PortID or the same
3409 * WWNN/WWPN duple, we enter the device into our database.
3410 */
3411
3412 for (portidx = 0; portidx < portlim; portidx++) {
3413 fcportdb_t *lp;
3414 isp_pdb_t pdb;
3415 uint64_t wwnn, wwpn;
3416 int dbidx, r, nr;
3417
3418 portid =
3419 ((rs1->snscb_ports[portidx].portid[0]) << 16) |
3420 ((rs1->snscb_ports[portidx].portid[1]) << 8) |
3421 ((rs1->snscb_ports[portidx].portid[2]));
3422
3423 if (portid == 0) {
3424 isp_prt(isp, ISP_LOGSANCFG,
3425 "skipping null PortID at idx %d", portidx);
3426 continue;
3427 }
3428
3429 /*
3430 * Skip ourselves...
3431 */
3432 if (portid == fcp->isp_portid) {
3433 isp_prt(isp, ISP_LOGSANCFG,
3434 "skip ourselves @ PortID 0x%06x", portid);
3435 continue;
3436 }
3437 isp_prt(isp, ISP_LOGSANCFG,
3438 "Checking Fabric Port 0x%06x", portid);
3439
3440 /*
3441 * We now search our Port Database for any
3442 * probational entries with this PortID. We don't
3443 * look for zombies here- only probational
3444 * entries (we've already logged out of zombies).
3445 */
3446 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3447 lp = &fcp->portdb[dbidx];
3448
3449 if (lp->state != FC_PORTDB_STATE_PROBATIONAL) {
3450 continue;
3451 }
3452 if (lp->portid == portid) {
3453 break;
3454 }
3455 }
3456
3457 /*
3458 * We found a probational entry with this Port ID.
3459 */
3460 if (dbidx < MAX_FC_TARG) {
3461 int handle_changed = 0;
3462
3463 lp = &fcp->portdb[dbidx];
3464
3465 /*
3466 * See if we're still logged into it.
3467 *
3468 * If we aren't, mark it as a dead device and
3469 * leave the new portid in the database entry
3470 * for somebody further along to decide what to
3471 * do (policy choice).
3472 *
3473 * If we are, check to see if it's the same
3474 * device still (it should be). If for some
3475 * reason it isn't, mark it as a changed device
3476 * and leave the new portid and role in the
3477 * database entry for somebody further along to
3478 * decide what to do (policy choice).
3479 *
3480 */
3481
3482 r = isp_getpdb(isp, lp->handle, &pdb, 0);
3483 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3484 FC_SCRATCH_RELEASE(isp);
3485 ISP_MARK_PORTDB(isp, 1);
3486 return (-1);
3487 }
3488 if (r != 0) {
3489 lp->new_portid = portid;
3490 lp->state = FC_PORTDB_STATE_DEAD;
3491 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3492 "Fabric Port 0x%06x considered dead",
3493 portid);
3494 continue;
3495 }
3496
3497
3498 /*
3499 * Check to make sure that handle, portid, WWPN and
3500 * WWNN agree. If they don't, then the association
3501 * between this PortID and the stated handle has been
3502 * broken by the firmware.
3503 */
3504 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3505 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3506 if (pdb.handle != lp->handle ||
3507 pdb.portid != portid ||
3508 wwpn != lp->port_wwn ||
3509 wwnn != lp->node_wwn) {
3510 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3511 fconf, dbidx, pdb.handle, pdb.portid,
3512 (uint32_t) (wwnn >> 32), (uint32_t) wwnn,
3513 (uint32_t) (wwpn >> 32), (uint32_t) wwpn,
3514 lp->handle, portid,
3515 (uint32_t) (lp->node_wwn >> 32),
3516 (uint32_t) lp->node_wwn,
3517 (uint32_t) (lp->port_wwn >> 32),
3518 (uint32_t) lp->port_wwn);
3519 /*
3520 * Try to re-login to this device using a
3521 * new handle. If that fails, mark it dead.
3522 *
3523 * isp_login_device will check for handle and
3524 * portid consistency after re-login.
3525 *
3526 */
3527 if (isp_login_device(isp, portid, &pdb,
3528 &oldhandle)) {
3529 lp->new_portid = portid;
3530 lp->state = FC_PORTDB_STATE_DEAD;
3531 if (fcp->isp_loopstate !=
3532 LOOP_SCANNING_FABRIC) {
3533 FC_SCRATCH_RELEASE(isp);
3534 ISP_MARK_PORTDB(isp, 1);
3535 return (-1);
3536 }
3537 continue;
3538 }
3539 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3540 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3541 if (wwpn != lp->port_wwn ||
3542 wwnn != lp->node_wwn) {
3543 isp_prt(isp, ISP_LOGWARN, "changed WWN"
3544 " after relogin");
3545 lp->new_portid = portid;
3546 lp->state = FC_PORTDB_STATE_DEAD;
3547 continue;
3548 }
3549
3550 lp->handle = pdb.handle;
3551 handle_changed++;
3552 }
3553
3554 nr = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
3555
3556 /*
3557 * Check to see whether the portid and roles have
3558 * stayed the same. If they have stayed the same,
3559 * we believe that this is the same device and it
3560 * hasn't become disconnected and reconnected, so
3561 * mark it as pending valid.
3562 *
3563 * If they aren't the same, mark the device as a
3564 * changed device and save the new port id and role
3565 * and let somebody else decide.
3566 */
3567
3568 lp->new_portid = portid;
3569 lp->new_roles = nr;
3570 if (pdb.portid != lp->portid || nr != lp->roles ||
3571 handle_changed) {
3572 isp_prt(isp, ISP_LOGSANCFG,
3573 "Fabric Port 0x%06x changed", portid);
3574 lp->state = FC_PORTDB_STATE_CHANGED;
3575 } else {
3576 isp_prt(isp, ISP_LOGSANCFG,
3577 "Fabric Port 0x%06x Now Pending Valid",
3578 portid);
3579 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3580 }
3581 continue;
3582 }
3583
3584 /*
3585 * Ah- a new entry. Search the database again for all non-NIL
3586 * entries to make sure we never ever make a new database entry
3587 * with the same port id. While we're at it, mark where the
3588 * last free entry was.
3589 */
3590
3591 dbidx = MAX_FC_TARG;
3592 for (lp = fcp->portdb; lp < &fcp->portdb[MAX_FC_TARG]; lp++) {
3593 if (lp >= &fcp->portdb[FL_ID] &&
3594 lp <= &fcp->portdb[SNS_ID]) {
3595 continue;
3596 }
3597 if (lp->state == FC_PORTDB_STATE_NIL) {
3598 if (dbidx == MAX_FC_TARG) {
3599 dbidx = lp - fcp->portdb;
3600 }
3601 continue;
3602 }
3603 if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
3604 continue;
3605 }
3606 if (lp->portid == portid) {
3607 break;
3608 }
3609 }
3610
3611 if (lp < &fcp->portdb[MAX_FC_TARG]) {
3612 isp_prt(isp, ISP_LOGWARN,
3613 "PortID 0x%06x already at %d handle %d state %d",
3614 portid, dbidx, lp->handle, lp->state);
3615 continue;
3616 }
3617
3618 /*
3619 * We should have the index of the first free entry seen.
3620 */
3621 if (dbidx == MAX_FC_TARG) {
3622 isp_prt(isp, ISP_LOGERR,
3623 "port database too small to login PortID 0x%06x"
3624 "- increase MAX_FC_TARG", portid);
3625 continue;
3626 }
3627
3628 /*
3629 * Otherwise, point to our new home.
3630 */
3631 lp = &fcp->portdb[dbidx];
3632
3633 /*
3634 * Try to see if we are logged into this device,
3635 * and maybe log into it.
3636 *
3637 * isp_login_device will check for handle and
3638 * portid consistency after login.
3639 */
3640 if (isp_login_device(isp, portid, &pdb, &oldhandle)) {
3641 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3642 FC_SCRATCH_RELEASE(isp);
3643 ISP_MARK_PORTDB(isp, 1);
3644 return (-1);
3645 }
3646 continue;
3647 }
3648
3649 handle = pdb.handle;
3650 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3651 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3652 nr = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
3653
3654 /*
3655 * And go through the database *one* more time to make sure
3656 * that we do not make more than one entry that has the same
3657 * WWNN/WWPN duple
3658 */
3659 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3660 if (dbidx >= FL_ID && dbidx <= SNS_ID) {
3661 continue;
3662 }
3663 if (fcp->portdb[dbidx].state == FC_PORTDB_STATE_NIL) {
3664 continue;
3665 }
3666 if (fcp->portdb[dbidx].node_wwn == wwnn &&
3667 fcp->portdb[dbidx].port_wwn == wwpn) {
3668 break;
3669 }
3670 }
3671
3672 if (dbidx == MAX_FC_TARG) {
3673 MEMZERO(lp, sizeof (fcportdb_t));
3674 lp->handle = handle;
3675 lp->node_wwn = wwnn;
3676 lp->port_wwn = wwpn;
3677 lp->new_portid = portid;
3678 lp->new_roles = nr;
3679 lp->state = FC_PORTDB_STATE_NEW;
3680 isp_prt(isp, ISP_LOGSANCFG,
3681 "Fabric Port 0x%06x is New Entry", portid);
3682 continue;
3683 }
3684
3685 if (fcp->portdb[dbidx].state != FC_PORTDB_STATE_ZOMBIE) {
3686 isp_prt(isp, ISP_LOGWARN,
3687 "PortID 0x%x 0x%08x%08x/0x%08x%08x %ld already at "
3688 "idx %d, state 0x%x", portid,
3689 (uint32_t) (wwnn >> 32), (uint32_t) wwnn,
3690 (uint32_t) (wwpn >> 32), (uint32_t) wwpn,
3691 (long) (lp - fcp->portdb), dbidx,
3692 fcp->portdb[dbidx].state);
3693 continue;
3694 }
3695
3696 /*
3697 * We found a zombie entry that matches us.
3698 * Revive it. We know that WWN and WWPN
3699 * are the same. For fabric devices, we
3700 * don't care that handle is different
3701 * as we assign that. If role or portid
3702 * are different, it maybe a changed device.
3703 */
3704 lp = &fcp->portdb[dbidx];
3705 lp->handle = handle;
3706 lp->new_portid = portid;
3707 lp->new_roles = nr;
3708 if (lp->portid != portid || lp->roles != nr) {
3709 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3710 "Zombie Fabric Port 0x%06x Now Changed", portid);
3711 lp->state = FC_PORTDB_STATE_CHANGED;
3712 } else {
3713 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3714 "Zombie Fabric Port 0x%06x Now Pending Valid",
3715 portid);
3716 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3717 }
3718 }
3719
3720 FC_SCRATCH_RELEASE(isp);
3721 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3722 ISP_MARK_PORTDB(isp, 1);
3723 return (-1);
3724 }
3725 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3726 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Scan Fabric Done");
3727 return (0);
3728}
3729
3730/*
3731 * Find an unused handle and try and use to login to a port.
3732 */
3733static int
3734isp_login_device(ispsoftc_t *isp, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)
3735{
3736 int lim, i, r;
3737 uint16_t handle;
3738
3739 if (FCPARAM(isp)->isp_2klogin) {
3740 lim = NPH_MAX_2K;
3741 } else {
3742 lim = NPH_MAX;
3743 }
3744
3745 handle = isp_nxt_handle(isp, *ohp);
3746 for (i = 0; i < lim; i++) {
3747 /*
3748 * See if we're still logged into something with
3749 * this handle and that something agrees with this
3750 * port id.
3751 */
3752 r = isp_getpdb(isp, handle, p, 0);
3753 if (r == 0 && p->portid != portid) {
3754 (void) isp_plogx(isp, handle, portid,
3755 PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT, 1);
3756 } else if (r == 0) {
3757 break;
3758 }
3759 if (FCPARAM(isp)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3760 return (-1);
3761 }
3762 /*
3763 * Now try and log into the device
3764 */
3765 r = isp_plogx(isp, handle, portid, PLOGX_FLG_CMD_PLOGI, 1);
3766 if (FCPARAM(isp)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3767 return (-1);
3768 }
3769 if (r == 0) {
3770 *ohp = handle;
3771 break;
3772 } else if ((r & 0xffff) == MBOX_PORT_ID_USED) {
3773 handle = r >> 16;
3774 break;
3775 } else if (r != MBOX_LOOP_ID_USED) {
3776 i = lim;
3777 break;
3778 } else {
3779 *ohp = handle;
3780 handle = isp_nxt_handle(isp, *ohp);
3781 }
3782 }
3783
3784 if (i == lim) {
3785 isp_prt(isp, ISP_LOGWARN, "PLOGI 0x%06x failed", portid);
3786 return (-1);
3787 }
3788
3789 /*
3790 * If we successfully logged into it, get the PDB for it
3791 * so we can crosscheck that it is still what we think it
3792 * is and that we also have the role it plays
3793 */
3794 r = isp_getpdb(isp, handle, p, 0);
3795 if (FCPARAM(isp)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3796 return (-1);
3797 }
3798 if (r != 0) {
3799 isp_prt(isp, ISP_LOGERR, "new device 0x%06x@0x%x disappeared",
3800 portid, handle);
3801 return (-1);
3802 }
3803
3804 if (p->handle != handle || p->portid != portid) {
3805 isp_prt(isp, ISP_LOGERR,
3806 "new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
3807 portid, handle, p->portid, p->handle);
3808 return (-1);
3809 }
3810 return (0);
3811}
3812
3813static int
3814isp_register_fc4_type(ispsoftc_t *isp)
3815{
3816 fcparam *fcp = isp->isp_param;
3817 uint8_t local[SNS_RFT_ID_REQ_SIZE];
3818 sns_screq_t *reqp = (sns_screq_t *) local;
3819 mbreg_t mbs;
3820
3821 MEMZERO((void *) reqp, SNS_RFT_ID_REQ_SIZE);
3822 reqp->snscb_rblen = SNS_RFT_ID_RESP_SIZE >> 1;
3823 reqp->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + 0x100);
3824 reqp->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + 0x100);
3825 reqp->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + 0x100);
3826 reqp->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + 0x100);
3827 reqp->snscb_sblen = 22;
3828 reqp->snscb_data[0] = SNS_RFT_ID;
3829 reqp->snscb_data[4] = fcp->isp_portid & 0xffff;
3830 reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff;
3831 reqp->snscb_data[6] = (1 << FC4_SCSI);
3832 FC_SCRATCH_ACQUIRE(isp);
3833 isp_put_sns_request(isp, reqp, (sns_screq_t *) fcp->isp_scratch);
3834 MEMZERO(&mbs, sizeof (mbs));
3835 mbs.param[0] = MBOX_SEND_SNS;
3836 mbs.param[1] = SNS_RFT_ID_REQ_SIZE >> 1;
3837 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
3838 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
3839 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
3840 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
3841 mbs.logval = MBLOGALL;
3842 mbs.timeout = 10000000;
3843 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_RFT_ID_REQ_SIZE);
3844 isp_mboxcmd(isp, &mbs);
3845 FC_SCRATCH_RELEASE(isp);
3846 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3847 return (0);
3848 } else {
3849 return (-1);
3850 }
3851}
3852
3853static int
3854isp_register_fc4_type_24xx(ispsoftc_t *isp)
3855{
3856 mbreg_t mbs;
3857 fcparam *fcp = FCPARAM(isp);
3858 union {
3859 isp_ct_pt_t plocal;
3860 rft_id_t clocal;
3861 uint8_t q[QENTRY_LEN];
3862 } un;
3863 isp_ct_pt_t *pt;
3864 ct_hdr_t *ct;
3865 rft_id_t *rp;
3866 uint8_t *scp = fcp->isp_scratch;
3867
3868 FC_SCRATCH_ACQUIRE(isp);
3869 /*
3870 * Build a Passthrough IOCB in memory.
3871 */
3872 MEMZERO(un.q, QENTRY_LEN);
3873 pt = &un.plocal;
3874 pt->ctp_header.rqs_entry_count = 1;
3875 pt->ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
3876 pt->ctp_handle = 0xffffffff;
3877 pt->ctp_nphdl = NPH_SNS_ID;
3878 pt->ctp_cmd_cnt = 1;
3879 pt->ctp_time = 1;
3880 pt->ctp_rsp_cnt = 1;
3881 pt->ctp_rsp_bcnt = sizeof (ct_hdr_t);
3882 pt->ctp_cmd_bcnt = sizeof (rft_id_t);
3883 pt->ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma+XTXOFF);
3884 pt->ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma+XTXOFF);
3885 pt->ctp_dataseg[0].ds_count = sizeof (rft_id_t);
3886 pt->ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma+IGPOFF);
3887 pt->ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma+IGPOFF);
3888 pt->ctp_dataseg[1].ds_count = sizeof (ct_hdr_t);
3889 isp_put_ct_pt(isp, pt, (isp_ct_pt_t *) &scp[CTXOFF]);
3890
3891 /*
3892 * Build the CT header and command in memory.
3893 *
3894 * Note that the CT header has to end up as Big Endian format in memory.
3895 */
3896 MEMZERO(&un.clocal, sizeof (un.clocal));
3897 ct = &un.clocal.rftid_hdr;
3898 ct->ct_revision = CT_REVISION;
3899 ct->ct_fcs_type = CT_FC_TYPE_FC;
3900 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3901 ct->ct_cmd_resp = SNS_RFT_ID;
3902 ct->ct_bcnt_resid = (sizeof (rft_id_t) - sizeof (ct_hdr_t)) >> 2;
3903 rp = &un.clocal;
3904 rp->rftid_portid[0] = fcp->isp_portid >> 16;
3905 rp->rftid_portid[1] = fcp->isp_portid >> 8;
3906 rp->rftid_portid[2] = fcp->isp_portid;
3907 rp->rftid_fc4types[FC4_SCSI >> 5] = 1 << (FC4_SCSI & 0x1f);
3908 isp_put_rft_id(isp, rp, (rft_id_t *) &scp[XTXOFF]);
3909
3910 MEMZERO(&scp[ZTXOFF], sizeof (ct_hdr_t));
3911
3912 MEMZERO(&mbs, sizeof (mbs));
3913 mbs.param[0] = MBOX_EXEC_COMMAND_IOCB_A64;
3914 mbs.param[1] = QENTRY_LEN;
3915 mbs.param[2] = DMA_WD1(fcp->isp_scdma + CTXOFF);
3916 mbs.param[3] = DMA_WD0(fcp->isp_scdma + CTXOFF);
3917 mbs.param[6] = DMA_WD3(fcp->isp_scdma + CTXOFF);
3918 mbs.param[7] = DMA_WD2(fcp->isp_scdma + CTXOFF);
3919 mbs.timeout = 500000;
3920 mbs.logval = MBLOGALL;
3921 MEMORYBARRIER(isp, SYNC_SFORDEV, XTXOFF, 2 * QENTRY_LEN);
3922 isp_mboxcmd(isp, &mbs);
3923 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3924 FC_SCRATCH_RELEASE(isp);
3925 return (-1);
3926 }
3927 MEMORYBARRIER(isp, SYNC_SFORCPU, ZTXOFF, QENTRY_LEN);
3928 pt = &un.plocal;
3929 isp_get_ct_pt(isp, (isp_ct_pt_t *) &scp[ZTXOFF], pt);
3930 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3931 isp_print_bytes(isp, "IOCB response", QENTRY_LEN, pt);
3932 }
3933 if (pt->ctp_status) {
3934 FC_SCRATCH_RELEASE(isp);
3935 isp_prt(isp, ISP_LOGWARN, "CT Passthrough returned 0x%x",
3936 pt->ctp_status);
3937 return (-1);
3938 }
3939
3940 isp_get_ct_hdr(isp, (ct_hdr_t *) &scp[IGPOFF], ct);
3941 FC_SCRATCH_RELEASE(isp);
3942
3943 if (ct->ct_cmd_resp == LS_RJT) {
3944 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3945 "Register FC4 Type rejected");
3946 return (-1);
3947 } else if (ct->ct_cmd_resp == LS_ACC) {
3948 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3949 "Register FC4 Type accepted");
3950 return(0);
3951 } else {
3952 isp_prt(isp, ISP_LOGWARN,
3953 "Register FC4 Type: 0x%x", ct->ct_cmd_resp);
3954 return (-1);
3955 }
3956}
3957
3958static uint16_t
3959isp_nxt_handle(ispsoftc_t *isp, uint16_t handle)
3960{
3961 int i;
3962 if (handle == NIL_HANDLE) {
3963 if (FCPARAM(isp)->isp_topo == TOPO_F_PORT) {
3964 handle = 0;
3965 } else {
3966 handle = SNS_ID+1;
3967 }
3968 } else {
3969 handle += 1;
3970 if (handle >= FL_ID && handle <= SNS_ID) {
3971 handle = SNS_ID+1;
3972 }
3973 if (handle >= NPH_RESERVED && handle <= NPH_FL_ID) {
3974 handle = NPH_FL_ID+1;
3975 }
3976 if (FCPARAM(isp)->isp_2klogin) {
3977 if (handle == NPH_MAX_2K) {
3978 handle = 0;
3979 }
3980 } else {
3981 if (handle == NPH_MAX) {
3982 handle = 0;
3983 }
3984 }
3985 }
3986 if (handle == FCPARAM(isp)->isp_loopid) {
3987 return (isp_nxt_handle(isp, handle));
3988 }
3989 for (i = 0; i < MAX_FC_TARG; i++) {
3990 if (FCPARAM(isp)->portdb[i].state == FC_PORTDB_STATE_NIL) {
3991 continue;
3992 }
3993 if (FCPARAM(isp)->portdb[i].handle == handle) {
3994 return (isp_nxt_handle(isp, handle));
3995 }
3996 }
3997 return (handle);
3998}
3999
4000/*
4001 * Start a command. Locking is assumed done in the caller.
4002 */
4003
4004int
4005isp_start(XS_T *xs)
4006{
4007 ispsoftc_t *isp;
4008 uint32_t nxti, optr, handle, isr;
4009 uint16_t sema, mbox;
4010 uint8_t local[QENTRY_LEN];
4011 ispreq_t *reqp, *qep;
4012 void *cdbp;
4013 uint16_t *tptr;
4014 int target, i, hdlidx = 0;
4015
4016 XS_INITERR(xs);
4017 isp = XS_ISP(xs);
4018
4019 /*
4020 * Check to make sure we're supporting initiator role.
4021 */
4022 if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
4023 XS_SETERR(xs, HBA_SELTIMEOUT);
4024 return (CMD_COMPLETE);
4025 }
4026
4027 /*
4028 * Now make sure we're running.
4029 */
4030
4031 if (isp->isp_state != ISP_RUNSTATE) {
4032 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4033 XS_SETERR(xs, HBA_BOTCH);
4034 return (CMD_COMPLETE);
4035 }
4036
4037 /*
4038 * Check command CDB length, etc.. We really are limited to 16 bytes
4039 * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
4040 * but probably only if we're running fairly new firmware (we'll
4041 * let the old f/w choke on an extended command queue entry).
4042 */
4043
4044 if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
4045 isp_prt(isp, ISP_LOGERR,
4046 "unsupported cdb length (%d, CDB[0]=0x%x)",
4047 XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
4048 XS_SETERR(xs, HBA_BOTCH);
4049 return (CMD_COMPLETE);
4050 }
4051
4052 /*
4053 * Translate the target to device handle as appropriate, checking
4054 * for correct device state as well.
4055 */
4056 target = XS_TGT(xs);
4057 if (IS_FC(isp)) {
4058 fcparam *fcp = isp->isp_param;
4059
4060 /*
4061 * Try again later.
4062 */
4063 if (fcp->isp_fwstate != FW_READY ||
4064 fcp->isp_loopstate != LOOP_READY) {
4065 return (CMD_RQLATER);
4066 }
4067
4068 if (XS_TGT(xs) >= MAX_FC_TARG) {
4069 XS_SETERR(xs, HBA_SELTIMEOUT);
4070 return (CMD_COMPLETE);
4071 }
4072
4073 hdlidx = fcp->isp_ini_map[XS_TGT(xs)] - 1;
4074 isp_prt(isp, ISP_LOGDEBUG1, "XS_TGT(xs)=%d- handle value %d",
4075 XS_TGT(xs), hdlidx);
4076 if (hdlidx < 0 || hdlidx >= MAX_FC_TARG) {
4077 XS_SETERR(xs, HBA_SELTIMEOUT);
4078 return (CMD_COMPLETE);
4079 }
4080 if (fcp->portdb[hdlidx].state == FC_PORTDB_STATE_ZOMBIE) {
4081 return (CMD_RQLATER);
4082 }
4083 if (fcp->portdb[hdlidx].state != FC_PORTDB_STATE_VALID) {
4084 XS_SETERR(xs, HBA_SELTIMEOUT);
4085 return (CMD_COMPLETE);
4086 }
4087 target = fcp->portdb[hdlidx].handle;
4088 }
4089
4090 /*
4091 * Next check to see if any HBA or Device parameters need to be updated.
4092 */
4093 if (isp->isp_update != 0) {
4094 isp_update(isp);
4095 }
4096
4097 start_again:
4098
4099 if (isp_getrqentry(isp, &nxti, &optr, (void *)&qep)) {
4100 isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow");
4101 XS_SETERR(xs, HBA_BOTCH);
4102 return (CMD_EAGAIN);
4103 }
4104
4105 /*
4106 * Now see if we need to synchronize the ISP with respect to anything.
4107 * We do dual duty here (cough) for synchronizing for busses other
4108 * than which we got here to send a command to.
4109 */
4110 reqp = (ispreq_t *) local;
4111 if (isp->isp_sendmarker) {
4112 if (IS_24XX(isp)) {
4113 isp_marker_24xx_t *m = (isp_marker_24xx_t *) qep;
4114 MEMZERO(m, QENTRY_LEN);
4115 m->mrk_header.rqs_entry_count = 1;
4116 m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4117 m->mrk_modifier = SYNC_ALL;
4118 isp_put_marker_24xx(isp, m, (isp_marker_24xx_t *)qep);
4119 ISP_ADD_REQUEST(isp, nxti);
4120 isp->isp_sendmarker = 0;
4121 goto start_again;
4122 } else {
4123 for (i = 0; i < (IS_DUALBUS(isp)? 2: 1); i++) {
4124 isp_marker_t *m = (isp_marker_t *) qep;
4125 if ((isp->isp_sendmarker & (1 << i)) == 0) {
4126 continue;
4127 }
4128 MEMZERO(m, QENTRY_LEN);
4129 m->mrk_header.rqs_entry_count = 1;
4130 m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4131 m->mrk_target = (i << 7); /* bus # */
4132 m->mrk_modifier = SYNC_ALL;
4133 isp_put_marker(isp, m, (isp_marker_t *) qep);
4134 ISP_ADD_REQUEST(isp, nxti);
4135 isp->isp_sendmarker &= ~(1 << i);
4136 goto start_again;
4137 }
4138 }
4139 }
4140
4141 MEMZERO((void *)reqp, QENTRY_LEN);
4142 reqp->req_header.rqs_entry_count = 1;
4143 if (IS_24XX(isp)) {
4144 reqp->req_header.rqs_entry_type = RQSTYPE_T7RQS;
4145 } else if (IS_FC(isp)) {
4146 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
4147 } else {
4148 if (XS_CDBLEN(xs) > 12)
4149 reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
4150 else
4151 reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
4152 }
4153 /* reqp->req_header.rqs_flags = 0; */
4154 /* reqp->req_header.rqs_seqno = 0; */
4155 if (IS_24XX(isp)) {
4156 int ttype;
4157 if (XS_TAG_P(xs)) {
4158 ttype = XS_TAG_TYPE(xs);
4159 } else {
4160 if (XS_CDBP(xs)[0] == 0x3) {
4161 ttype = REQFLAG_HTAG;
4162 } else {
4163 ttype = REQFLAG_STAG;
4164 }
4165 }
4166 if (ttype == REQFLAG_OTAG) {
4167 ttype = FCP_CMND_TASK_ATTR_ORDERED;
4168 } else if (ttype == REQFLAG_HTAG) {
4169 ttype = FCP_CMND_TASK_ATTR_HEAD;
4170 } else {
4171 ttype = FCP_CMND_TASK_ATTR_SIMPLE;
4172 }
4173 ((ispreqt7_t *)reqp)->req_task_attribute = ttype;
4174 } else if (IS_FC(isp)) {
4175 /*
4176 * See comment in isp_intr
4177 */
4178 /* XS_RESID(xs) = 0; */
4179
4180 /*
4181 * Fibre Channel always requires some kind of tag.
4182 * The Qlogic drivers seem be happy not to use a tag,
4183 * but this breaks for some devices (IBM drives).
4184 */
4185 if (XS_TAG_P(xs)) {
4186 ((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs);
4187 } else {
4188 /*
4189 * If we don't know what tag to use, use HEAD OF QUEUE
4190 * for Request Sense or Simple.
4191 */
4192 if (XS_CDBP(xs)[0] == 0x3) /* REQUEST SENSE */
4193 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_HTAG;
4194 else
4195 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_STAG;
4196 }
4197 } else {
4198 sdparam *sdp = (sdparam *)isp->isp_param;
4199 sdp += XS_CHANNEL(xs);
4200 if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) &&
4201 XS_TAG_P(xs)) {
4202 reqp->req_flags = XS_TAG_TYPE(xs);
4203 }
4204 }
4205 cdbp = reqp->req_cdb;
4206 tptr = &reqp->req_time;
4207
4208 if (IS_SCSI(isp)) {
4209 reqp->req_target = target | (XS_CHANNEL(xs) << 7);
4210 reqp->req_lun_trn = XS_LUN(xs);
4211 reqp->req_cdblen = XS_CDBLEN(xs);
4212 } else if (IS_24XX(isp)) {
4213 fcportdb_t *lp;
4214
4215 lp = &FCPARAM(isp)->portdb[hdlidx];
4216 ((ispreqt7_t *)reqp)->req_nphdl = target;
4217 ((ispreqt7_t *)reqp)->req_tidlo = lp->portid;
4218 ((ispreqt7_t *)reqp)->req_tidhi = lp->portid >> 16;
4219 if (XS_LUN(xs) > 256) {
4220 ((ispreqt7_t *)reqp)->req_lun[0] = XS_LUN(xs) >> 8;
4221 ((ispreqt7_t *)reqp)->req_lun[0] |= 0x40;
4222 }
4223 ((ispreqt7_t *)reqp)->req_lun[1] = XS_LUN(xs);
4224 cdbp = ((ispreqt7_t *)reqp)->req_cdb;
4225 tptr = &((ispreqt7_t *)reqp)->req_time;
4226 } else if (FCPARAM(isp)->isp_2klogin) {
4227 ((ispreqt2e_t *)reqp)->req_target = target;
4228 ((ispreqt2e_t *)reqp)->req_scclun = XS_LUN(xs);
4229 } else if (FCPARAM(isp)->isp_sccfw) {
4230 ((ispreqt2_t *)reqp)->req_target = target;
4231 ((ispreqt2_t *)reqp)->req_scclun = XS_LUN(xs);
4232 } else {
4233 ((ispreqt2_t *)reqp)->req_target = target;
4234 ((ispreqt2_t *)reqp)->req_lun_trn = XS_LUN(xs);
4235 }
4236 MEMCPY(cdbp, XS_CDBP(xs), XS_CDBLEN(xs));
4237
4238 *tptr = XS_TIME(xs) / 1000;
4239 if (*tptr == 0 && XS_TIME(xs)) {
4240 *tptr = 1;
4241 }
4242 if (IS_24XX(isp) && *tptr > 0x1999) {
4243 *tptr = 0x1999;
4244 }
4245
4246 if (isp_save_xs(isp, xs, &handle)) {
4247 isp_prt(isp, ISP_LOGDEBUG0, "out of xflist pointers");
4248 XS_SETERR(xs, HBA_BOTCH);
4249 return (CMD_EAGAIN);
4250 }
4251 /* Whew. Thankfully the same for type 7 requests */
4252 reqp->req_handle = handle;
4253
4254 /*
4255 * Set up DMA and/or do any bus swizzling of the request entry
4256 * so that the Qlogic F/W understands what is being asked of it.
4257 */
4258 i = ISP_DMASETUP(isp, xs, reqp, &nxti, optr);
4259 if (i != CMD_QUEUED) {
4260 isp_destroy_handle(isp, handle);
4261 /*
4262 * dmasetup sets actual error in packet, and
4263 * return what we were given to return.
4264 */
4265 return (i);
4266 }
4267 XS_SETERR(xs, HBA_NOERROR);
4268 isp_prt(isp, ISP_LOGDEBUG2,
4269 "START cmd for %d.%d.%d cmd 0x%x datalen %ld",
4270 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), XS_CDBP(xs)[0],
4271 (long) XS_XFRLEN(xs));
4272 ISP_ADD_REQUEST(isp, nxti);
4273 isp->isp_nactive++;
4274 if (IS_23XX(isp) || IS_24XX(isp)) {
4275 if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
4276 isp_intr(isp, isr, sema, mbox);
4277 }
4278 }
4279 return (CMD_QUEUED);
4280}
4281
4282/*
4283 * isp control
4284 * Locks (ints blocked) assumed held.
4285 */
4286
4287int
4288isp_control(ispsoftc_t *isp, ispctl_t ctl, void *arg)
4289{
4290 XS_T *xs;
4291 mbreg_t mbs;
4292 int bus, tgt;
4293 uint32_t handle;
4294
4295 MEMZERO(&mbs, sizeof (mbs));
4296
4297 switch (ctl) {
4298 default:
4299 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
4300 break;
4301
4302 case ISPCTL_RESET_BUS:
4303 /*
4304 * Issue a bus reset.
4305 */
4306 if (IS_24XX(isp)) {
4307 isp_prt(isp, ISP_LOGWARN, "RESET BUS NOT IMPLETENTED");
4308 break;
4309 } else if (IS_FC(isp)) {
4310 mbs.param[1] = 10;
4311 bus = 0;
4312 } else {
4313 mbs.param[1] = SDPARAM(isp)->isp_bus_reset_delay;
4314 if (mbs.param[1] < 2) {
4315 mbs.param[1] = 2;
4316 }
4317 bus = *((int *) arg);
4318 if (IS_DUALBUS(isp)) {
4319 mbs.param[2] = bus;
4320 }
4321 }
4322 mbs.param[0] = MBOX_BUS_RESET;
4323 isp->isp_sendmarker |= (1 << bus);
4324 mbs.logval = MBLOGALL;
4325 isp_mboxcmd(isp, &mbs);
4326 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4327 break;
4328 }
4329 isp_prt(isp, ISP_LOGINFO,
4330 "driver initiated bus reset of bus %d", bus);
4331 return (0);
4332
4333 case ISPCTL_RESET_DEV:
4334 tgt = (*((int *) arg)) & 0xffff;
4335 if (IS_24XX(isp)) {
4336 isp_prt(isp, ISP_LOGWARN, "RESET DEV NOT IMPLETENTED");
4337 break;
4338 } else if (IS_FC(isp)) {
4339 if (FCPARAM(isp)->isp_2klogin) {
4340 mbs.param[1] = tgt;
4341 mbs.ibits = (1 << 10);
4342 } else {
4343 mbs.param[1] = (tgt << 8);
4344 }
4345 bus = 0;
4346 } else {
4347 bus = (*((int *) arg)) >> 16;
4348 mbs.param[1] = (bus << 15) | (tgt << 8);
4349 }
4350 mbs.param[0] = MBOX_ABORT_TARGET;
4351 mbs.param[2] = 3; /* 'delay', in seconds */
4352 mbs.logval = MBLOGALL;
4353 isp_mboxcmd(isp, &mbs);
4354 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4355 break;
4356 }
4357 isp_prt(isp, ISP_LOGINFO,
4358 "Target %d on Bus %d Reset Succeeded", tgt, bus);
4359 isp->isp_sendmarker |= (1 << bus);
4360 return (0);
4361
4362 case ISPCTL_ABORT_CMD:
4363 xs = (XS_T *) arg;
4364 tgt = XS_TGT(xs);
4365
4366 handle = isp_find_handle(isp, xs);
4367 if (handle == 0) {
4368 isp_prt(isp, ISP_LOGWARN,
4369 "cannot find handle for command to abort");
4370 break;
4371 }
4372 if (IS_24XX(isp)) {
4373 isp_prt(isp, ISP_LOGWARN, "ABORT CMD NOT IMPLETENTED");
4374 break;
4375 } else if (IS_FC(isp)) {
4376 if (FCPARAM(isp)->isp_sccfw) {
4377 if (FCPARAM(isp)->isp_2klogin) {
4378 mbs.param[1] = tgt;
4379 } else {
4380 mbs.param[1] = tgt << 8;
4381 }
4382 mbs.param[6] = XS_LUN(xs);
4383 } else {
4384 mbs.param[1] = tgt << 8 | XS_LUN(xs);
4385 }
4386 } else {
4387 bus = XS_CHANNEL(xs);
4388 mbs.param[1] = (bus << 15) | (tgt << 8) | XS_LUN(xs);
4389 }
4390 mbs.param[0] = MBOX_ABORT;
4391 mbs.param[2] = handle;
4392 mbs.logval = MBLOGALL & ~MBOX_COMMAND_ERROR;
4393 isp_mboxcmd(isp, &mbs);
4394 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4395 break;
4396 }
4397 return (0);
4398
4399 case ISPCTL_UPDATE_PARAMS:
4400
4401 isp_update(isp);
4402 return (0);
4403
4404 case ISPCTL_FCLINK_TEST:
4405
4406 if (IS_FC(isp)) {
4407 int usdelay = *((int *) arg);
4408 if (usdelay == 0) {
4409 usdelay = 250000;
4410 }
4411 return (isp_fclink_test(isp, usdelay));
4412 }
4413 break;
4414
4415 case ISPCTL_SCAN_FABRIC:
4416
4417 if (IS_FC(isp)) {
4418 return (isp_scan_fabric(isp));
4419 }
4420 break;
4421
4422 case ISPCTL_SCAN_LOOP:
4423
4424 if (IS_FC(isp)) {
4425 return (isp_scan_loop(isp));
4426 }
4427 break;
4428
4429 case ISPCTL_PDB_SYNC:
4430
4431 if (IS_FC(isp)) {
4432 return (isp_pdb_sync(isp));
4433 }
4434 break;
4435
4436 case ISPCTL_SEND_LIP:
4437
4438 if (IS_FC(isp) && !IS_24XX(isp)) {
4439 mbs.param[0] = MBOX_INIT_LIP;
4440 if (FCPARAM(isp)->isp_2klogin) {
4441 mbs.ibits = (1 << 10);
4442 }
4443 mbs.logval = MBLOGALL;
4444 isp_mboxcmd(isp, &mbs);
4445 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
4446 return (0);
4447 }
4448 }
4449 break;
4450
4451 case ISPCTL_GET_PDB:
4452 if (IS_FC(isp) && arg) {
4453 int id = *((int *)arg);
4454 isp_pdb_t *pdb = arg;
4455 return (isp_getpdb(isp, id, pdb, 1));
4456 }
4457 break;
4458
4459 case ISPCTL_GET_PORTNAME:
4460 {
4461 uint64_t *wwnp = arg;
4462 int loopid = *wwnp;
4463 *wwnp = isp_get_portname(isp, loopid, 0);
4464 if (*wwnp == (uint64_t) -1) {
4465 break;
4466 } else {
4467 return (0);
4468 }
4469 }
4470 case ISPCTL_RUN_MBOXCMD:
4471
4472 isp_mboxcmd(isp, arg);
4473 return(0);
4474
4475 case ISPCTL_PLOGX:
4476 {
4477 isp_plcmd_t *p = arg;
4478 int r;
4479
4480 if ((p->flags & PLOGX_FLG_CMD_MASK) != PLOGX_FLG_CMD_PLOGI ||
4481 (p->handle != NIL_HANDLE)) {
4482 return (isp_plogx(isp, p->handle, p->portid,
4483 p->flags, 0));
4484 }
4485 do {
4486 p->handle = isp_nxt_handle(isp, p->handle);
4487 r = isp_plogx(isp, p->handle, p->portid, p->flags, 0);
4488 if ((r & 0xffff) == MBOX_PORT_ID_USED) {
4489 p->handle = r >> 16;
4490 r = 0;
4491 break;
4492 }
4493 } while ((r & 0xffff) == MBOX_LOOP_ID_USED);
4494 return (r);
4495 }
4496#ifdef ISP_TARGET_MODE
4497 case ISPCTL_TOGGLE_TMODE:
4498 {
4499
4500 /*
4501 * We don't check/set against role here- that's the
4502 * responsibility for the outer layer to coordinate.
4503 */
4504 if (IS_SCSI(isp)) {
4505 int param = *(int *)arg;
4506 mbs.param[0] = MBOX_ENABLE_TARGET_MODE;
4507 mbs.param[1] = param & 0xffff;
4508 mbs.param[2] = param >> 16;
4509 mbs.logval = MBLOGALL;
4510 isp_mboxcmd(isp, &mbs);
4511 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4512 break;
4513 }
4514 }
4515 return (0);
4516 }
4517#endif
4518 }
4519 return (-1);
4520}
4521
4522/*
4523 * Interrupt Service Routine(s).
4524 *
4525 * External (OS) framework has done the appropriate locking,
4526 * and the locking will be held throughout this function.
4527 */
4528
4529/*
4530 * Limit our stack depth by sticking with the max likely number
4531 * of completions on a request queue at any one time.
4532 */
4533#ifndef MAX_REQUESTQ_COMPLETIONS
4534#define MAX_REQUESTQ_COMPLETIONS 32
4535#endif
4536
4537void
4538isp_intr(ispsoftc_t *isp, uint32_t isr, uint16_t sema, uint16_t mbox)
4539{
4540 XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
4541 uint32_t iptr, optr, junk;
4542 int i, nlooked = 0, ndone = 0;
4543
4544again:
4545 optr = isp->isp_residx;
4546 /*
4547 * Is this a mailbox related interrupt?
4548 * The mailbox semaphore will be nonzero if so.
4549 */
4550 if (sema) {
4551 if (mbox & 0x4000) {
4552 isp->isp_intmboxc++;
4553 if (isp->isp_mboxbsy) {
4554 int i = 0, obits = isp->isp_obits;
4555 isp->isp_mboxtmp[i++] = mbox;
4556 for (i = 1; i < MAX_MAILBOX(isp); i++) {
4557 if ((obits & (1 << i)) == 0) {
4558 continue;
4559 }
4560 isp->isp_mboxtmp[i] =
4561 ISP_READ(isp, MBOX_OFF(i));
4562 }
4563 if (isp->isp_mbxwrk0) {
4564 if (isp_mbox_continue(isp) == 0) {
4565 return;
4566 }
4567 }
4568 MBOX_NOTIFY_COMPLETE(isp);
4569 } else {
4570 isp_prt(isp, ISP_LOGWARN,
4571 "mailbox cmd (0x%x) with no waiters", mbox);
4572 }
4573 } else if (isp_parse_async(isp, mbox) < 0) {
4574 return;
4575 }
4576 if ((IS_FC(isp) && mbox != ASYNC_RIO_RESP) ||
4577 isp->isp_state != ISP_RUNSTATE) {
4578 goto out;
| 2962 continue;
2963 }
2964
2965 /*
2966 * Now search the entire port database
2967 * for the same Port and Node WWN.
2968 */
2969 for (i = 0; i < MAX_FC_TARG; i++) {
2970 lp = &fcp->portdb[i];
2971 if (lp->state == FC_PORTDB_STATE_NIL) {
2972 continue;
2973 }
2974 if (lp->node_wwn != tmp.node_wwn) {
2975 continue;
2976 }
2977 if (lp->port_wwn != tmp.port_wwn) {
2978 continue;
2979 }
2980
2981 /*
2982 * Okay- we've found a non-nil entry that matches.
2983 * Check to make sure it's probational or a zombie.
2984 */
2985 if (lp->state != FC_PORTDB_STATE_PROBATIONAL &&
2986 lp->state != FC_PORTDB_STATE_ZOMBIE) {
2987 isp_prt(isp, ISP_LOGERR,
2988 "[%d] not probational/zombie (0x%x)",
2989 i, lp->state);
2990 isp_dump_portdb(isp);
2991 ISP_MARK_PORTDB(isp, 1);
2992 return (-1);
2993 }
2994
2995 /*
2996 * Mark the device as something the f/w logs into
2997 * automatically.
2998 */
2999 lp->autologin = 1;
3000
3001 /*
3002 * Check to make see if really still the same
3003 * device. If it is, we mark it pending valid.
3004 */
3005 if (lp->portid == tmp.portid &&
3006 lp->handle == tmp.handle &&
3007 lp->roles == tmp.roles) {
3008 lp->new_portid = tmp.portid;
3009 lp->new_roles = tmp.roles;
3010 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3011 isp_prt(isp, ISP_LOGSANCFG,
3012 "Loop Port 0x%02x@0x%x Pending Valid",
3013 tmp.portid, tmp.handle);
3014 break;
3015 }
3016
3017 /*
3018 * We can wipe out the old handle value
3019 * here because it's no longer valid.
3020 */
3021 lp->handle = tmp.handle;
3022
3023 /*
3024 * Claim that this has changed and let somebody else
3025 * decide what to do.
3026 */
3027 isp_prt(isp, ISP_LOGSANCFG,
3028 "Loop Port 0x%02x@0x%x changed",
3029 tmp.portid, tmp.handle);
3030 lp->state = FC_PORTDB_STATE_CHANGED;
3031 lp->new_portid = tmp.portid;
3032 lp->new_roles = tmp.roles;
3033 break;
3034 }
3035
3036 /*
3037 * Did we find and update an old entry?
3038 */
3039 if (i < MAX_FC_TARG) {
3040 continue;
3041 }
3042
3043 /*
3044 * Ah. A new device entry. Find an empty slot
3045 * for it and save info for later disposition.
3046 */
3047 for (i = 0; i < MAX_FC_TARG; i++) {
3048 if (fcp->portdb[i].state == FC_PORTDB_STATE_NIL) {
3049 break;
3050 }
3051 }
3052 if (i == MAX_FC_TARG) {
3053 isp_prt(isp, ISP_LOGERR, "out of portdb entries");
3054 continue;
3055 }
3056 lp = &fcp->portdb[i];
3057
3058 MEMZERO(lp, sizeof (fcportdb_t));
3059 lp->autologin = 1;
3060 lp->state = FC_PORTDB_STATE_NEW;
3061 lp->new_portid = tmp.portid;
3062 lp->new_roles = tmp.roles;
3063 lp->handle = tmp.handle;
3064 lp->port_wwn = tmp.port_wwn;
3065 lp->node_wwn = tmp.node_wwn;
3066 isp_prt(isp, ISP_LOGSANCFG,
3067 "Loop Port 0x%02x@0x%x is New Entry",
3068 tmp.portid, tmp.handle);
3069 }
3070 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3071 return (0);
3072}
3073
3074/*
3075 * Scan the fabric for devices and add them to our port database.
3076 *
3077 * Use the GID_FT command to get all Port IDs for FC4 SCSI devices it knows.
3078 *
3079 * For 2100-23XX cards, we can use the SNS mailbox command to pass simple
3080 * name server commands to the switch management server via the QLogic f/w.
3081 *
3082 * For the 24XX card, we have to use CT-Pass through run via the Execute IOCB
3083 * mailbox command.
3084 *
3085 * The net result is to leave the list of Port IDs setting untranslated in
3086 * offset IGPOFF of the FC scratch area, whereupon we'll canonicalize it to
3087 * host order at OGPOFF.
3088 */
3089
3090/*
3091 * Take less than half of our scratch area to store Port IDs
3092 */
3093#define GIDLEN ((ISP2100_SCRLEN >> 1) - 16 - SNS_GID_FT_REQ_SIZE)
3094#define NGENT ((GIDLEN - 16) >> 2)
3095
3096#define IGPOFF (2 * QENTRY_LEN)
3097#define OGPOFF (ISP2100_SCRLEN >> 1)
3098#define ZTXOFF (ISP2100_SCRLEN - (1 * QENTRY_LEN))
3099#define CTXOFF (ISP2100_SCRLEN - (2 * QENTRY_LEN))
3100#define XTXOFF (ISP2100_SCRLEN - (3 * QENTRY_LEN))
3101
3102static int
3103isp_gid_ft_sns(ispsoftc_t *isp)
3104{
3105 union {
3106 sns_gid_ft_req_t _x;
3107 uint8_t _y[SNS_GID_FT_REQ_SIZE];
3108 } un;
3109 fcparam *fcp = FCPARAM(isp);
3110 sns_gid_ft_req_t *rq = &un._x;
3111 mbreg_t mbs;
3112
3113 isp_prt(isp, ISP_LOGDEBUG0, "scanning fabric (GID_FT) via SNS");
3114
3115 MEMZERO(rq, SNS_GID_FT_REQ_SIZE);
3116 rq->snscb_rblen = GIDLEN >> 1;
3117 rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + IGPOFF);
3118 rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + IGPOFF);
3119 rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + IGPOFF);
3120 rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + IGPOFF);
3121 rq->snscb_sblen = 6;
3122 rq->snscb_cmd = SNS_GID_FT;
3123 rq->snscb_mword_div_2 = NGENT;
3124 rq->snscb_fc4_type = FC4_SCSI;
3125
3126 isp_put_gid_ft_request(isp, rq, fcp->isp_scratch);
3127 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GID_FT_REQ_SIZE);
3128
3129 MEMZERO(&mbs, sizeof (mbs));
3130 mbs.param[0] = MBOX_SEND_SNS;
3131 mbs.param[1] = SNS_GID_FT_REQ_SIZE >> 1;
3132 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
3133 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
3134 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
3135 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
3136 mbs.logval = MBLOGALL;
3137 mbs.timeout = 10000000;
3138 isp_mboxcmd(isp, &mbs);
3139 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3140 if (mbs.param[0] == MBOX_INVALID_COMMAND) {
3141 return (1);
3142 } else {
3143 return (-1);
3144 }
3145 }
3146 return (0);
3147}
3148
3149static int
3150isp_gid_ft_ct_passthru(ispsoftc_t *isp)
3151{
3152 mbreg_t mbs;
3153 fcparam *fcp = FCPARAM(isp);
3154 union {
3155 isp_ct_pt_t plocal;
3156 ct_hdr_t clocal;
3157 uint8_t q[QENTRY_LEN];
3158 } un;
3159 isp_ct_pt_t *pt;
3160 ct_hdr_t *ct;
3161 uint32_t *rp;
3162 uint8_t *scp = fcp->isp_scratch;
3163
3164 isp_prt(isp, ISP_LOGDEBUG0, "scanning fabric (GID_FT) via CT");
3165
3166 if (!IS_24XX(isp)) {
3167 return (1);
3168 }
3169
3170 /*
3171 * Build a Passthrough IOCB in memory.
3172 */
3173 pt = &un.plocal;
3174 MEMZERO(un.q, QENTRY_LEN);
3175 pt->ctp_header.rqs_entry_count = 1;
3176 pt->ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
3177 pt->ctp_handle = 0xffffffff;
3178 pt->ctp_nphdl = NPH_SNS_ID;
3179 pt->ctp_cmd_cnt = 1;
3180 pt->ctp_time = 30;
3181 pt->ctp_rsp_cnt = 1;
3182 pt->ctp_rsp_bcnt = GIDLEN;
3183 pt->ctp_cmd_bcnt = sizeof (*ct) + sizeof (uint32_t);
3184 pt->ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma+XTXOFF);
3185 pt->ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma+XTXOFF);
3186 pt->ctp_dataseg[0].ds_count = sizeof (*ct) + sizeof (uint32_t);
3187 pt->ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma+IGPOFF);
3188 pt->ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma+IGPOFF);
3189 pt->ctp_dataseg[1].ds_count = GIDLEN;
3190 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3191 isp_print_bytes(isp, "ct IOCB", QENTRY_LEN, pt);
3192 }
3193 isp_put_ct_pt(isp, pt, (isp_ct_pt_t *) &scp[CTXOFF]);
3194
3195 /*
3196 * Build the CT header and command in memory.
3197 *
3198 * Note that the CT header has to end up as Big Endian format in memory.
3199 */
3200 ct = &un.clocal;
3201 MEMZERO(ct, sizeof (*ct));
3202 ct->ct_revision = CT_REVISION;
3203 ct->ct_fcs_type = CT_FC_TYPE_FC;
3204 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3205 ct->ct_cmd_resp = SNS_GID_FT;
3206 ct->ct_bcnt_resid = (GIDLEN - 16) >> 2;
3207
3208 isp_put_ct_hdr(isp, ct, (ct_hdr_t *) &scp[XTXOFF]);
3209 rp = (uint32_t *) &scp[XTXOFF+sizeof (*ct)];
3210 ISP_IOZPUT_32(isp, FC4_SCSI, rp);
3211 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3212 isp_print_bytes(isp, "CT HDR + payload after put",
3213 sizeof (*ct) + sizeof (uint32_t), &scp[XTXOFF]);
3214 }
3215 MEMZERO(&scp[ZTXOFF], QENTRY_LEN);
3216 MEMZERO(&mbs, sizeof (mbs));
3217 mbs.param[0] = MBOX_EXEC_COMMAND_IOCB_A64;
3218 mbs.param[1] = QENTRY_LEN;
3219 mbs.param[2] = DMA_WD1(fcp->isp_scdma + CTXOFF);
3220 mbs.param[3] = DMA_WD0(fcp->isp_scdma + CTXOFF);
3221 mbs.param[6] = DMA_WD3(fcp->isp_scdma + CTXOFF);
3222 mbs.param[7] = DMA_WD2(fcp->isp_scdma + CTXOFF);
3223 mbs.timeout = 500000;
3224 mbs.logval = MBLOGALL;
3225 MEMORYBARRIER(isp, SYNC_SFORDEV, XTXOFF, 2 * QENTRY_LEN);
3226 isp_mboxcmd(isp, &mbs);
3227 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3228 return (-1);
3229 }
3230 MEMORYBARRIER(isp, SYNC_SFORCPU, ZTXOFF, QENTRY_LEN);
3231 pt = &un.plocal;
3232 isp_get_ct_pt(isp, (isp_ct_pt_t *) &scp[ZTXOFF], pt);
3233 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3234 isp_print_bytes(isp, "IOCB response", QENTRY_LEN, pt);
3235 }
3236
3237 if (pt->ctp_status && pt->ctp_status != RQCS_DATA_UNDERRUN) {
3238 isp_prt(isp, ISP_LOGWARN, "CT Passthrough returned 0x%x",
3239 pt->ctp_status);
3240 return (-1);
3241 }
3242 MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN + 16);
3243 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3244 isp_print_bytes(isp, "CT response", GIDLEN+16, &scp[IGPOFF]);
3245 }
3246 return (0);
3247}
3248
3249static int
3250isp_scan_fabric(ispsoftc_t *isp)
3251{
3252 fcparam *fcp = FCPARAM(isp);
3253 uint32_t portid;
3254 uint16_t handle, oldhandle;
3255 int portidx, portlim, r;
3256 sns_gid_ft_rsp_t *rs0, *rs1;
3257
3258 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Scan Fabric");
3259 if (fcp->isp_fwstate != FW_READY ||
3260 fcp->isp_loopstate < LOOP_LSCAN_DONE) {
3261 return (-1);
3262 }
3263 if (fcp->isp_loopstate > LOOP_SCANNING_FABRIC) {
3264 return (0);
3265 }
3266 if (fcp->isp_topo != TOPO_FL_PORT && fcp->isp_topo != TOPO_F_PORT) {
3267 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3268 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3269 "FC Scan Fabric Done (no fabric)");
3270 return (0);
3271 }
3272
3273 FC_SCRATCH_ACQUIRE(isp);
3274 fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
3275
3276 if (IS_24XX(isp)) {
3277 r = isp_gid_ft_ct_passthru(isp);
3278 } else {
3279 r = isp_gid_ft_sns(isp);
3280 }
3281
3282 if (r > 0) {
3283 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3284 FC_SCRATCH_RELEASE(isp);
3285 return (0);
3286 } else if (r < 0) {
3287 fcp->isp_loopstate = LOOP_PDB_RCVD; /* try again */
3288 FC_SCRATCH_RELEASE(isp);
3289 return (0);
3290 }
3291 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3292 FC_SCRATCH_RELEASE(isp);
3293 return (-1);
3294 }
3295
3296 MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN);
3297 rs0 = (sns_gid_ft_rsp_t *) ((uint8_t *)fcp->isp_scratch+IGPOFF);
3298 rs1 = (sns_gid_ft_rsp_t *) ((uint8_t *)fcp->isp_scratch+OGPOFF);
3299 isp_get_gid_ft_response(isp, rs0, rs1, NGENT);
3300 if (rs1->snscb_cthdr.ct_cmd_resp != LS_ACC) {
3301 int level;
3302 if (rs1->snscb_cthdr.ct_reason == 9 &&
3303 rs1->snscb_cthdr.ct_explanation == 7) {
3304 level = ISP_LOGSANCFG|ISP_LOGDEBUG0;
3305 } else {
3306 level = ISP_LOGWARN;
3307 }
3308 isp_prt(isp, level, "Fabric Nameserver rejected GID_FT "
3309 "(Reason=0x%x Expl=0x%x)", rs1->snscb_cthdr.ct_reason,
3310 rs1->snscb_cthdr.ct_explanation);
3311 FC_SCRATCH_RELEASE(isp);
3312 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3313 return (0);
3314 }
3315
3316
3317 /*
3318 * If we get this far, we certainly still have the fabric controller.
3319 */
3320 fcp->portdb[FL_ID].state = FC_PORTDB_STATE_PENDING_VALID;
3321
3322 /*
3323 * Prime the handle we will start using.
3324 */
3325 oldhandle = NIL_HANDLE;
3326
3327 /*
3328 * Okay, we now have a list of Port IDs for all FC4 SCSI devices
3329 * that the Fabric Name server knows about. Go through the list
3330 * and remove duplicate port ids.
3331 */
3332
3333 portlim = 0;
3334 portidx = 0;
3335 for (portidx = 0; portidx < NGENT-1; portidx++) {
3336 if (rs1->snscb_ports[portidx].control & 0x80) {
3337 break;
3338 }
3339 }
3340
3341 /*
3342 * If we're not at the last entry, our list wasn't big enough.
3343 */
3344 if ((rs1->snscb_ports[portidx].control & 0x80) == 0) {
3345 isp_prt(isp, ISP_LOGWARN,
3346 "fabric too big for scratch area: increase ISP2100_SCRLEN");
3347 }
3348 portlim = portidx + 1;
3349 isp_prt(isp, ISP_LOGSANCFG,
3350 "got %d ports back from name server", portlim);
3351
3352 for (portidx = 0; portidx < portlim; portidx++) {
3353 int npidx;
3354
3355 portid =
3356 ((rs1->snscb_ports[portidx].portid[0]) << 16) |
3357 ((rs1->snscb_ports[portidx].portid[1]) << 8) |
3358 ((rs1->snscb_ports[portidx].portid[2]));
3359
3360 for (npidx = portidx + 1; npidx < portlim; npidx++) {
3361 uint32_t new_portid =
3362 ((rs1->snscb_ports[npidx].portid[0]) << 16) |
3363 ((rs1->snscb_ports[npidx].portid[1]) << 8) |
3364 ((rs1->snscb_ports[npidx].portid[2]));
3365 if (new_portid == portid) {
3366 break;
3367 }
3368 }
3369
3370 if (npidx < portlim) {
3371 rs1->snscb_ports[npidx].portid[0] = 0;
3372 rs1->snscb_ports[npidx].portid[1] = 0;
3373 rs1->snscb_ports[npidx].portid[2] = 0;
3374 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3375 "removing duplicate PortID 0x%x entry from list",
3376 portid);
3377 }
3378 }
3379
3380 /*
3381 * Okay, we now have a list of Port IDs for all FC4 SCSI devices
3382 * that the Fabric Name server knows about.
3383 *
3384 * For each entry on this list go through our port database looking
3385 * for probational entries- if we find one, then an old entry is
3386 * is maybe still this one. We get some information to find out.
3387 *
3388 * Otherwise, it's a new fabric device, and we log into it
3389 * (unconditionally). After searching the entire database
3390 * again to make sure that we never ever ever ever have more
3391 * than one entry that has the same PortID or the same
3392 * WWNN/WWPN duple, we enter the device into our database.
3393 */
3394
3395 for (portidx = 0; portidx < portlim; portidx++) {
3396 fcportdb_t *lp;
3397 isp_pdb_t pdb;
3398 uint64_t wwnn, wwpn;
3399 int dbidx, r, nr;
3400
3401 portid =
3402 ((rs1->snscb_ports[portidx].portid[0]) << 16) |
3403 ((rs1->snscb_ports[portidx].portid[1]) << 8) |
3404 ((rs1->snscb_ports[portidx].portid[2]));
3405
3406 if (portid == 0) {
3407 isp_prt(isp, ISP_LOGSANCFG,
3408 "skipping null PortID at idx %d", portidx);
3409 continue;
3410 }
3411
3412 /*
3413 * Skip ourselves...
3414 */
3415 if (portid == fcp->isp_portid) {
3416 isp_prt(isp, ISP_LOGSANCFG,
3417 "skip ourselves @ PortID 0x%06x", portid);
3418 continue;
3419 }
3420 isp_prt(isp, ISP_LOGSANCFG,
3421 "Checking Fabric Port 0x%06x", portid);
3422
3423 /*
3424 * We now search our Port Database for any
3425 * probational entries with this PortID. We don't
3426 * look for zombies here- only probational
3427 * entries (we've already logged out of zombies).
3428 */
3429 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3430 lp = &fcp->portdb[dbidx];
3431
3432 if (lp->state != FC_PORTDB_STATE_PROBATIONAL) {
3433 continue;
3434 }
3435 if (lp->portid == portid) {
3436 break;
3437 }
3438 }
3439
3440 /*
3441 * We found a probational entry with this Port ID.
3442 */
3443 if (dbidx < MAX_FC_TARG) {
3444 int handle_changed = 0;
3445
3446 lp = &fcp->portdb[dbidx];
3447
3448 /*
3449 * See if we're still logged into it.
3450 *
3451 * If we aren't, mark it as a dead device and
3452 * leave the new portid in the database entry
3453 * for somebody further along to decide what to
3454 * do (policy choice).
3455 *
3456 * If we are, check to see if it's the same
3457 * device still (it should be). If for some
3458 * reason it isn't, mark it as a changed device
3459 * and leave the new portid and role in the
3460 * database entry for somebody further along to
3461 * decide what to do (policy choice).
3462 *
3463 */
3464
3465 r = isp_getpdb(isp, lp->handle, &pdb, 0);
3466 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3467 FC_SCRATCH_RELEASE(isp);
3468 ISP_MARK_PORTDB(isp, 1);
3469 return (-1);
3470 }
3471 if (r != 0) {
3472 lp->new_portid = portid;
3473 lp->state = FC_PORTDB_STATE_DEAD;
3474 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3475 "Fabric Port 0x%06x considered dead",
3476 portid);
3477 continue;
3478 }
3479
3480
3481 /*
3482 * Check to make sure that handle, portid, WWPN and
3483 * WWNN agree. If they don't, then the association
3484 * between this PortID and the stated handle has been
3485 * broken by the firmware.
3486 */
3487 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3488 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3489 if (pdb.handle != lp->handle ||
3490 pdb.portid != portid ||
3491 wwpn != lp->port_wwn ||
3492 wwnn != lp->node_wwn) {
3493 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3494 fconf, dbidx, pdb.handle, pdb.portid,
3495 (uint32_t) (wwnn >> 32), (uint32_t) wwnn,
3496 (uint32_t) (wwpn >> 32), (uint32_t) wwpn,
3497 lp->handle, portid,
3498 (uint32_t) (lp->node_wwn >> 32),
3499 (uint32_t) lp->node_wwn,
3500 (uint32_t) (lp->port_wwn >> 32),
3501 (uint32_t) lp->port_wwn);
3502 /*
3503 * Try to re-login to this device using a
3504 * new handle. If that fails, mark it dead.
3505 *
3506 * isp_login_device will check for handle and
3507 * portid consistency after re-login.
3508 *
3509 */
3510 if (isp_login_device(isp, portid, &pdb,
3511 &oldhandle)) {
3512 lp->new_portid = portid;
3513 lp->state = FC_PORTDB_STATE_DEAD;
3514 if (fcp->isp_loopstate !=
3515 LOOP_SCANNING_FABRIC) {
3516 FC_SCRATCH_RELEASE(isp);
3517 ISP_MARK_PORTDB(isp, 1);
3518 return (-1);
3519 }
3520 continue;
3521 }
3522 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3523 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3524 if (wwpn != lp->port_wwn ||
3525 wwnn != lp->node_wwn) {
3526 isp_prt(isp, ISP_LOGWARN, "changed WWN"
3527 " after relogin");
3528 lp->new_portid = portid;
3529 lp->state = FC_PORTDB_STATE_DEAD;
3530 continue;
3531 }
3532
3533 lp->handle = pdb.handle;
3534 handle_changed++;
3535 }
3536
3537 nr = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
3538
3539 /*
3540 * Check to see whether the portid and roles have
3541 * stayed the same. If they have stayed the same,
3542 * we believe that this is the same device and it
3543 * hasn't become disconnected and reconnected, so
3544 * mark it as pending valid.
3545 *
3546 * If they aren't the same, mark the device as a
3547 * changed device and save the new port id and role
3548 * and let somebody else decide.
3549 */
3550
3551 lp->new_portid = portid;
3552 lp->new_roles = nr;
3553 if (pdb.portid != lp->portid || nr != lp->roles ||
3554 handle_changed) {
3555 isp_prt(isp, ISP_LOGSANCFG,
3556 "Fabric Port 0x%06x changed", portid);
3557 lp->state = FC_PORTDB_STATE_CHANGED;
3558 } else {
3559 isp_prt(isp, ISP_LOGSANCFG,
3560 "Fabric Port 0x%06x Now Pending Valid",
3561 portid);
3562 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3563 }
3564 continue;
3565 }
3566
3567 /*
3568 * Ah- a new entry. Search the database again for all non-NIL
3569 * entries to make sure we never ever make a new database entry
3570 * with the same port id. While we're at it, mark where the
3571 * last free entry was.
3572 */
3573
3574 dbidx = MAX_FC_TARG;
3575 for (lp = fcp->portdb; lp < &fcp->portdb[MAX_FC_TARG]; lp++) {
3576 if (lp >= &fcp->portdb[FL_ID] &&
3577 lp <= &fcp->portdb[SNS_ID]) {
3578 continue;
3579 }
3580 if (lp->state == FC_PORTDB_STATE_NIL) {
3581 if (dbidx == MAX_FC_TARG) {
3582 dbidx = lp - fcp->portdb;
3583 }
3584 continue;
3585 }
3586 if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
3587 continue;
3588 }
3589 if (lp->portid == portid) {
3590 break;
3591 }
3592 }
3593
3594 if (lp < &fcp->portdb[MAX_FC_TARG]) {
3595 isp_prt(isp, ISP_LOGWARN,
3596 "PortID 0x%06x already at %d handle %d state %d",
3597 portid, dbidx, lp->handle, lp->state);
3598 continue;
3599 }
3600
3601 /*
3602 * We should have the index of the first free entry seen.
3603 */
3604 if (dbidx == MAX_FC_TARG) {
3605 isp_prt(isp, ISP_LOGERR,
3606 "port database too small to login PortID 0x%06x"
3607 "- increase MAX_FC_TARG", portid);
3608 continue;
3609 }
3610
3611 /*
3612 * Otherwise, point to our new home.
3613 */
3614 lp = &fcp->portdb[dbidx];
3615
3616 /*
3617 * Try to see if we are logged into this device,
3618 * and maybe log into it.
3619 *
3620 * isp_login_device will check for handle and
3621 * portid consistency after login.
3622 */
3623 if (isp_login_device(isp, portid, &pdb, &oldhandle)) {
3624 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3625 FC_SCRATCH_RELEASE(isp);
3626 ISP_MARK_PORTDB(isp, 1);
3627 return (-1);
3628 }
3629 continue;
3630 }
3631
3632 handle = pdb.handle;
3633 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3634 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3635 nr = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
3636
3637 /*
3638 * And go through the database *one* more time to make sure
3639 * that we do not make more than one entry that has the same
3640 * WWNN/WWPN duple
3641 */
3642 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3643 if (dbidx >= FL_ID && dbidx <= SNS_ID) {
3644 continue;
3645 }
3646 if (fcp->portdb[dbidx].state == FC_PORTDB_STATE_NIL) {
3647 continue;
3648 }
3649 if (fcp->portdb[dbidx].node_wwn == wwnn &&
3650 fcp->portdb[dbidx].port_wwn == wwpn) {
3651 break;
3652 }
3653 }
3654
3655 if (dbidx == MAX_FC_TARG) {
3656 MEMZERO(lp, sizeof (fcportdb_t));
3657 lp->handle = handle;
3658 lp->node_wwn = wwnn;
3659 lp->port_wwn = wwpn;
3660 lp->new_portid = portid;
3661 lp->new_roles = nr;
3662 lp->state = FC_PORTDB_STATE_NEW;
3663 isp_prt(isp, ISP_LOGSANCFG,
3664 "Fabric Port 0x%06x is New Entry", portid);
3665 continue;
3666 }
3667
3668 if (fcp->portdb[dbidx].state != FC_PORTDB_STATE_ZOMBIE) {
3669 isp_prt(isp, ISP_LOGWARN,
3670 "PortID 0x%x 0x%08x%08x/0x%08x%08x %ld already at "
3671 "idx %d, state 0x%x", portid,
3672 (uint32_t) (wwnn >> 32), (uint32_t) wwnn,
3673 (uint32_t) (wwpn >> 32), (uint32_t) wwpn,
3674 (long) (lp - fcp->portdb), dbidx,
3675 fcp->portdb[dbidx].state);
3676 continue;
3677 }
3678
3679 /*
3680 * We found a zombie entry that matches us.
3681 * Revive it. We know that WWN and WWPN
3682 * are the same. For fabric devices, we
3683 * don't care that handle is different
3684 * as we assign that. If role or portid
3685 * are different, it maybe a changed device.
3686 */
3687 lp = &fcp->portdb[dbidx];
3688 lp->handle = handle;
3689 lp->new_portid = portid;
3690 lp->new_roles = nr;
3691 if (lp->portid != portid || lp->roles != nr) {
3692 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3693 "Zombie Fabric Port 0x%06x Now Changed", portid);
3694 lp->state = FC_PORTDB_STATE_CHANGED;
3695 } else {
3696 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3697 "Zombie Fabric Port 0x%06x Now Pending Valid",
3698 portid);
3699 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3700 }
3701 }
3702
3703 FC_SCRATCH_RELEASE(isp);
3704 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3705 ISP_MARK_PORTDB(isp, 1);
3706 return (-1);
3707 }
3708 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3709 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Scan Fabric Done");
3710 return (0);
3711}
3712
3713/*
3714 * Find an unused handle and try and use to login to a port.
3715 */
3716static int
3717isp_login_device(ispsoftc_t *isp, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)
3718{
3719 int lim, i, r;
3720 uint16_t handle;
3721
3722 if (FCPARAM(isp)->isp_2klogin) {
3723 lim = NPH_MAX_2K;
3724 } else {
3725 lim = NPH_MAX;
3726 }
3727
3728 handle = isp_nxt_handle(isp, *ohp);
3729 for (i = 0; i < lim; i++) {
3730 /*
3731 * See if we're still logged into something with
3732 * this handle and that something agrees with this
3733 * port id.
3734 */
3735 r = isp_getpdb(isp, handle, p, 0);
3736 if (r == 0 && p->portid != portid) {
3737 (void) isp_plogx(isp, handle, portid,
3738 PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT, 1);
3739 } else if (r == 0) {
3740 break;
3741 }
3742 if (FCPARAM(isp)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3743 return (-1);
3744 }
3745 /*
3746 * Now try and log into the device
3747 */
3748 r = isp_plogx(isp, handle, portid, PLOGX_FLG_CMD_PLOGI, 1);
3749 if (FCPARAM(isp)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3750 return (-1);
3751 }
3752 if (r == 0) {
3753 *ohp = handle;
3754 break;
3755 } else if ((r & 0xffff) == MBOX_PORT_ID_USED) {
3756 handle = r >> 16;
3757 break;
3758 } else if (r != MBOX_LOOP_ID_USED) {
3759 i = lim;
3760 break;
3761 } else {
3762 *ohp = handle;
3763 handle = isp_nxt_handle(isp, *ohp);
3764 }
3765 }
3766
3767 if (i == lim) {
3768 isp_prt(isp, ISP_LOGWARN, "PLOGI 0x%06x failed", portid);
3769 return (-1);
3770 }
3771
3772 /*
3773 * If we successfully logged into it, get the PDB for it
3774 * so we can crosscheck that it is still what we think it
3775 * is and that we also have the role it plays
3776 */
3777 r = isp_getpdb(isp, handle, p, 0);
3778 if (FCPARAM(isp)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3779 return (-1);
3780 }
3781 if (r != 0) {
3782 isp_prt(isp, ISP_LOGERR, "new device 0x%06x@0x%x disappeared",
3783 portid, handle);
3784 return (-1);
3785 }
3786
3787 if (p->handle != handle || p->portid != portid) {
3788 isp_prt(isp, ISP_LOGERR,
3789 "new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
3790 portid, handle, p->portid, p->handle);
3791 return (-1);
3792 }
3793 return (0);
3794}
3795
3796static int
3797isp_register_fc4_type(ispsoftc_t *isp)
3798{
3799 fcparam *fcp = isp->isp_param;
3800 uint8_t local[SNS_RFT_ID_REQ_SIZE];
3801 sns_screq_t *reqp = (sns_screq_t *) local;
3802 mbreg_t mbs;
3803
3804 MEMZERO((void *) reqp, SNS_RFT_ID_REQ_SIZE);
3805 reqp->snscb_rblen = SNS_RFT_ID_RESP_SIZE >> 1;
3806 reqp->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + 0x100);
3807 reqp->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + 0x100);
3808 reqp->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + 0x100);
3809 reqp->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + 0x100);
3810 reqp->snscb_sblen = 22;
3811 reqp->snscb_data[0] = SNS_RFT_ID;
3812 reqp->snscb_data[4] = fcp->isp_portid & 0xffff;
3813 reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff;
3814 reqp->snscb_data[6] = (1 << FC4_SCSI);
3815 FC_SCRATCH_ACQUIRE(isp);
3816 isp_put_sns_request(isp, reqp, (sns_screq_t *) fcp->isp_scratch);
3817 MEMZERO(&mbs, sizeof (mbs));
3818 mbs.param[0] = MBOX_SEND_SNS;
3819 mbs.param[1] = SNS_RFT_ID_REQ_SIZE >> 1;
3820 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
3821 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
3822 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
3823 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
3824 mbs.logval = MBLOGALL;
3825 mbs.timeout = 10000000;
3826 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_RFT_ID_REQ_SIZE);
3827 isp_mboxcmd(isp, &mbs);
3828 FC_SCRATCH_RELEASE(isp);
3829 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3830 return (0);
3831 } else {
3832 return (-1);
3833 }
3834}
3835
3836static int
3837isp_register_fc4_type_24xx(ispsoftc_t *isp)
3838{
3839 mbreg_t mbs;
3840 fcparam *fcp = FCPARAM(isp);
3841 union {
3842 isp_ct_pt_t plocal;
3843 rft_id_t clocal;
3844 uint8_t q[QENTRY_LEN];
3845 } un;
3846 isp_ct_pt_t *pt;
3847 ct_hdr_t *ct;
3848 rft_id_t *rp;
3849 uint8_t *scp = fcp->isp_scratch;
3850
3851 FC_SCRATCH_ACQUIRE(isp);
3852 /*
3853 * Build a Passthrough IOCB in memory.
3854 */
3855 MEMZERO(un.q, QENTRY_LEN);
3856 pt = &un.plocal;
3857 pt->ctp_header.rqs_entry_count = 1;
3858 pt->ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
3859 pt->ctp_handle = 0xffffffff;
3860 pt->ctp_nphdl = NPH_SNS_ID;
3861 pt->ctp_cmd_cnt = 1;
3862 pt->ctp_time = 1;
3863 pt->ctp_rsp_cnt = 1;
3864 pt->ctp_rsp_bcnt = sizeof (ct_hdr_t);
3865 pt->ctp_cmd_bcnt = sizeof (rft_id_t);
3866 pt->ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma+XTXOFF);
3867 pt->ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma+XTXOFF);
3868 pt->ctp_dataseg[0].ds_count = sizeof (rft_id_t);
3869 pt->ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma+IGPOFF);
3870 pt->ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma+IGPOFF);
3871 pt->ctp_dataseg[1].ds_count = sizeof (ct_hdr_t);
3872 isp_put_ct_pt(isp, pt, (isp_ct_pt_t *) &scp[CTXOFF]);
3873
3874 /*
3875 * Build the CT header and command in memory.
3876 *
3877 * Note that the CT header has to end up as Big Endian format in memory.
3878 */
3879 MEMZERO(&un.clocal, sizeof (un.clocal));
3880 ct = &un.clocal.rftid_hdr;
3881 ct->ct_revision = CT_REVISION;
3882 ct->ct_fcs_type = CT_FC_TYPE_FC;
3883 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3884 ct->ct_cmd_resp = SNS_RFT_ID;
3885 ct->ct_bcnt_resid = (sizeof (rft_id_t) - sizeof (ct_hdr_t)) >> 2;
3886 rp = &un.clocal;
3887 rp->rftid_portid[0] = fcp->isp_portid >> 16;
3888 rp->rftid_portid[1] = fcp->isp_portid >> 8;
3889 rp->rftid_portid[2] = fcp->isp_portid;
3890 rp->rftid_fc4types[FC4_SCSI >> 5] = 1 << (FC4_SCSI & 0x1f);
3891 isp_put_rft_id(isp, rp, (rft_id_t *) &scp[XTXOFF]);
3892
3893 MEMZERO(&scp[ZTXOFF], sizeof (ct_hdr_t));
3894
3895 MEMZERO(&mbs, sizeof (mbs));
3896 mbs.param[0] = MBOX_EXEC_COMMAND_IOCB_A64;
3897 mbs.param[1] = QENTRY_LEN;
3898 mbs.param[2] = DMA_WD1(fcp->isp_scdma + CTXOFF);
3899 mbs.param[3] = DMA_WD0(fcp->isp_scdma + CTXOFF);
3900 mbs.param[6] = DMA_WD3(fcp->isp_scdma + CTXOFF);
3901 mbs.param[7] = DMA_WD2(fcp->isp_scdma + CTXOFF);
3902 mbs.timeout = 500000;
3903 mbs.logval = MBLOGALL;
3904 MEMORYBARRIER(isp, SYNC_SFORDEV, XTXOFF, 2 * QENTRY_LEN);
3905 isp_mboxcmd(isp, &mbs);
3906 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3907 FC_SCRATCH_RELEASE(isp);
3908 return (-1);
3909 }
3910 MEMORYBARRIER(isp, SYNC_SFORCPU, ZTXOFF, QENTRY_LEN);
3911 pt = &un.plocal;
3912 isp_get_ct_pt(isp, (isp_ct_pt_t *) &scp[ZTXOFF], pt);
3913 if (isp->isp_dblev & ISP_LOGDEBUG1) {
3914 isp_print_bytes(isp, "IOCB response", QENTRY_LEN, pt);
3915 }
3916 if (pt->ctp_status) {
3917 FC_SCRATCH_RELEASE(isp);
3918 isp_prt(isp, ISP_LOGWARN, "CT Passthrough returned 0x%x",
3919 pt->ctp_status);
3920 return (-1);
3921 }
3922
3923 isp_get_ct_hdr(isp, (ct_hdr_t *) &scp[IGPOFF], ct);
3924 FC_SCRATCH_RELEASE(isp);
3925
3926 if (ct->ct_cmd_resp == LS_RJT) {
3927 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3928 "Register FC4 Type rejected");
3929 return (-1);
3930 } else if (ct->ct_cmd_resp == LS_ACC) {
3931 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3932 "Register FC4 Type accepted");
3933 return(0);
3934 } else {
3935 isp_prt(isp, ISP_LOGWARN,
3936 "Register FC4 Type: 0x%x", ct->ct_cmd_resp);
3937 return (-1);
3938 }
3939}
3940
3941static uint16_t
3942isp_nxt_handle(ispsoftc_t *isp, uint16_t handle)
3943{
3944 int i;
3945 if (handle == NIL_HANDLE) {
3946 if (FCPARAM(isp)->isp_topo == TOPO_F_PORT) {
3947 handle = 0;
3948 } else {
3949 handle = SNS_ID+1;
3950 }
3951 } else {
3952 handle += 1;
3953 if (handle >= FL_ID && handle <= SNS_ID) {
3954 handle = SNS_ID+1;
3955 }
3956 if (handle >= NPH_RESERVED && handle <= NPH_FL_ID) {
3957 handle = NPH_FL_ID+1;
3958 }
3959 if (FCPARAM(isp)->isp_2klogin) {
3960 if (handle == NPH_MAX_2K) {
3961 handle = 0;
3962 }
3963 } else {
3964 if (handle == NPH_MAX) {
3965 handle = 0;
3966 }
3967 }
3968 }
3969 if (handle == FCPARAM(isp)->isp_loopid) {
3970 return (isp_nxt_handle(isp, handle));
3971 }
3972 for (i = 0; i < MAX_FC_TARG; i++) {
3973 if (FCPARAM(isp)->portdb[i].state == FC_PORTDB_STATE_NIL) {
3974 continue;
3975 }
3976 if (FCPARAM(isp)->portdb[i].handle == handle) {
3977 return (isp_nxt_handle(isp, handle));
3978 }
3979 }
3980 return (handle);
3981}
3982
3983/*
3984 * Start a command. Locking is assumed done in the caller.
3985 */
3986
3987int
3988isp_start(XS_T *xs)
3989{
3990 ispsoftc_t *isp;
3991 uint32_t nxti, optr, handle, isr;
3992 uint16_t sema, mbox;
3993 uint8_t local[QENTRY_LEN];
3994 ispreq_t *reqp, *qep;
3995 void *cdbp;
3996 uint16_t *tptr;
3997 int target, i, hdlidx = 0;
3998
3999 XS_INITERR(xs);
4000 isp = XS_ISP(xs);
4001
4002 /*
4003 * Check to make sure we're supporting initiator role.
4004 */
4005 if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
4006 XS_SETERR(xs, HBA_SELTIMEOUT);
4007 return (CMD_COMPLETE);
4008 }
4009
4010 /*
4011 * Now make sure we're running.
4012 */
4013
4014 if (isp->isp_state != ISP_RUNSTATE) {
4015 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4016 XS_SETERR(xs, HBA_BOTCH);
4017 return (CMD_COMPLETE);
4018 }
4019
4020 /*
4021 * Check command CDB length, etc.. We really are limited to 16 bytes
4022 * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
4023 * but probably only if we're running fairly new firmware (we'll
4024 * let the old f/w choke on an extended command queue entry).
4025 */
4026
4027 if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
4028 isp_prt(isp, ISP_LOGERR,
4029 "unsupported cdb length (%d, CDB[0]=0x%x)",
4030 XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
4031 XS_SETERR(xs, HBA_BOTCH);
4032 return (CMD_COMPLETE);
4033 }
4034
4035 /*
4036 * Translate the target to device handle as appropriate, checking
4037 * for correct device state as well.
4038 */
4039 target = XS_TGT(xs);
4040 if (IS_FC(isp)) {
4041 fcparam *fcp = isp->isp_param;
4042
4043 /*
4044 * Try again later.
4045 */
4046 if (fcp->isp_fwstate != FW_READY ||
4047 fcp->isp_loopstate != LOOP_READY) {
4048 return (CMD_RQLATER);
4049 }
4050
4051 if (XS_TGT(xs) >= MAX_FC_TARG) {
4052 XS_SETERR(xs, HBA_SELTIMEOUT);
4053 return (CMD_COMPLETE);
4054 }
4055
4056 hdlidx = fcp->isp_ini_map[XS_TGT(xs)] - 1;
4057 isp_prt(isp, ISP_LOGDEBUG1, "XS_TGT(xs)=%d- handle value %d",
4058 XS_TGT(xs), hdlidx);
4059 if (hdlidx < 0 || hdlidx >= MAX_FC_TARG) {
4060 XS_SETERR(xs, HBA_SELTIMEOUT);
4061 return (CMD_COMPLETE);
4062 }
4063 if (fcp->portdb[hdlidx].state == FC_PORTDB_STATE_ZOMBIE) {
4064 return (CMD_RQLATER);
4065 }
4066 if (fcp->portdb[hdlidx].state != FC_PORTDB_STATE_VALID) {
4067 XS_SETERR(xs, HBA_SELTIMEOUT);
4068 return (CMD_COMPLETE);
4069 }
4070 target = fcp->portdb[hdlidx].handle;
4071 }
4072
4073 /*
4074 * Next check to see if any HBA or Device parameters need to be updated.
4075 */
4076 if (isp->isp_update != 0) {
4077 isp_update(isp);
4078 }
4079
4080 start_again:
4081
4082 if (isp_getrqentry(isp, &nxti, &optr, (void *)&qep)) {
4083 isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow");
4084 XS_SETERR(xs, HBA_BOTCH);
4085 return (CMD_EAGAIN);
4086 }
4087
4088 /*
4089 * Now see if we need to synchronize the ISP with respect to anything.
4090 * We do dual duty here (cough) for synchronizing for busses other
4091 * than which we got here to send a command to.
4092 */
4093 reqp = (ispreq_t *) local;
4094 if (isp->isp_sendmarker) {
4095 if (IS_24XX(isp)) {
4096 isp_marker_24xx_t *m = (isp_marker_24xx_t *) qep;
4097 MEMZERO(m, QENTRY_LEN);
4098 m->mrk_header.rqs_entry_count = 1;
4099 m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4100 m->mrk_modifier = SYNC_ALL;
4101 isp_put_marker_24xx(isp, m, (isp_marker_24xx_t *)qep);
4102 ISP_ADD_REQUEST(isp, nxti);
4103 isp->isp_sendmarker = 0;
4104 goto start_again;
4105 } else {
4106 for (i = 0; i < (IS_DUALBUS(isp)? 2: 1); i++) {
4107 isp_marker_t *m = (isp_marker_t *) qep;
4108 if ((isp->isp_sendmarker & (1 << i)) == 0) {
4109 continue;
4110 }
4111 MEMZERO(m, QENTRY_LEN);
4112 m->mrk_header.rqs_entry_count = 1;
4113 m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4114 m->mrk_target = (i << 7); /* bus # */
4115 m->mrk_modifier = SYNC_ALL;
4116 isp_put_marker(isp, m, (isp_marker_t *) qep);
4117 ISP_ADD_REQUEST(isp, nxti);
4118 isp->isp_sendmarker &= ~(1 << i);
4119 goto start_again;
4120 }
4121 }
4122 }
4123
4124 MEMZERO((void *)reqp, QENTRY_LEN);
4125 reqp->req_header.rqs_entry_count = 1;
4126 if (IS_24XX(isp)) {
4127 reqp->req_header.rqs_entry_type = RQSTYPE_T7RQS;
4128 } else if (IS_FC(isp)) {
4129 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
4130 } else {
4131 if (XS_CDBLEN(xs) > 12)
4132 reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
4133 else
4134 reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
4135 }
4136 /* reqp->req_header.rqs_flags = 0; */
4137 /* reqp->req_header.rqs_seqno = 0; */
4138 if (IS_24XX(isp)) {
4139 int ttype;
4140 if (XS_TAG_P(xs)) {
4141 ttype = XS_TAG_TYPE(xs);
4142 } else {
4143 if (XS_CDBP(xs)[0] == 0x3) {
4144 ttype = REQFLAG_HTAG;
4145 } else {
4146 ttype = REQFLAG_STAG;
4147 }
4148 }
4149 if (ttype == REQFLAG_OTAG) {
4150 ttype = FCP_CMND_TASK_ATTR_ORDERED;
4151 } else if (ttype == REQFLAG_HTAG) {
4152 ttype = FCP_CMND_TASK_ATTR_HEAD;
4153 } else {
4154 ttype = FCP_CMND_TASK_ATTR_SIMPLE;
4155 }
4156 ((ispreqt7_t *)reqp)->req_task_attribute = ttype;
4157 } else if (IS_FC(isp)) {
4158 /*
4159 * See comment in isp_intr
4160 */
4161 /* XS_RESID(xs) = 0; */
4162
4163 /*
4164 * Fibre Channel always requires some kind of tag.
4165 * The Qlogic drivers seem be happy not to use a tag,
4166 * but this breaks for some devices (IBM drives).
4167 */
4168 if (XS_TAG_P(xs)) {
4169 ((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs);
4170 } else {
4171 /*
4172 * If we don't know what tag to use, use HEAD OF QUEUE
4173 * for Request Sense or Simple.
4174 */
4175 if (XS_CDBP(xs)[0] == 0x3) /* REQUEST SENSE */
4176 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_HTAG;
4177 else
4178 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_STAG;
4179 }
4180 } else {
4181 sdparam *sdp = (sdparam *)isp->isp_param;
4182 sdp += XS_CHANNEL(xs);
4183 if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) &&
4184 XS_TAG_P(xs)) {
4185 reqp->req_flags = XS_TAG_TYPE(xs);
4186 }
4187 }
4188 cdbp = reqp->req_cdb;
4189 tptr = &reqp->req_time;
4190
4191 if (IS_SCSI(isp)) {
4192 reqp->req_target = target | (XS_CHANNEL(xs) << 7);
4193 reqp->req_lun_trn = XS_LUN(xs);
4194 reqp->req_cdblen = XS_CDBLEN(xs);
4195 } else if (IS_24XX(isp)) {
4196 fcportdb_t *lp;
4197
4198 lp = &FCPARAM(isp)->portdb[hdlidx];
4199 ((ispreqt7_t *)reqp)->req_nphdl = target;
4200 ((ispreqt7_t *)reqp)->req_tidlo = lp->portid;
4201 ((ispreqt7_t *)reqp)->req_tidhi = lp->portid >> 16;
4202 if (XS_LUN(xs) > 256) {
4203 ((ispreqt7_t *)reqp)->req_lun[0] = XS_LUN(xs) >> 8;
4204 ((ispreqt7_t *)reqp)->req_lun[0] |= 0x40;
4205 }
4206 ((ispreqt7_t *)reqp)->req_lun[1] = XS_LUN(xs);
4207 cdbp = ((ispreqt7_t *)reqp)->req_cdb;
4208 tptr = &((ispreqt7_t *)reqp)->req_time;
4209 } else if (FCPARAM(isp)->isp_2klogin) {
4210 ((ispreqt2e_t *)reqp)->req_target = target;
4211 ((ispreqt2e_t *)reqp)->req_scclun = XS_LUN(xs);
4212 } else if (FCPARAM(isp)->isp_sccfw) {
4213 ((ispreqt2_t *)reqp)->req_target = target;
4214 ((ispreqt2_t *)reqp)->req_scclun = XS_LUN(xs);
4215 } else {
4216 ((ispreqt2_t *)reqp)->req_target = target;
4217 ((ispreqt2_t *)reqp)->req_lun_trn = XS_LUN(xs);
4218 }
4219 MEMCPY(cdbp, XS_CDBP(xs), XS_CDBLEN(xs));
4220
4221 *tptr = XS_TIME(xs) / 1000;
4222 if (*tptr == 0 && XS_TIME(xs)) {
4223 *tptr = 1;
4224 }
4225 if (IS_24XX(isp) && *tptr > 0x1999) {
4226 *tptr = 0x1999;
4227 }
4228
4229 if (isp_save_xs(isp, xs, &handle)) {
4230 isp_prt(isp, ISP_LOGDEBUG0, "out of xflist pointers");
4231 XS_SETERR(xs, HBA_BOTCH);
4232 return (CMD_EAGAIN);
4233 }
4234 /* Whew. Thankfully the same for type 7 requests */
4235 reqp->req_handle = handle;
4236
4237 /*
4238 * Set up DMA and/or do any bus swizzling of the request entry
4239 * so that the Qlogic F/W understands what is being asked of it.
4240 */
4241 i = ISP_DMASETUP(isp, xs, reqp, &nxti, optr);
4242 if (i != CMD_QUEUED) {
4243 isp_destroy_handle(isp, handle);
4244 /*
4245 * dmasetup sets actual error in packet, and
4246 * return what we were given to return.
4247 */
4248 return (i);
4249 }
4250 XS_SETERR(xs, HBA_NOERROR);
4251 isp_prt(isp, ISP_LOGDEBUG2,
4252 "START cmd for %d.%d.%d cmd 0x%x datalen %ld",
4253 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), XS_CDBP(xs)[0],
4254 (long) XS_XFRLEN(xs));
4255 ISP_ADD_REQUEST(isp, nxti);
4256 isp->isp_nactive++;
4257 if (IS_23XX(isp) || IS_24XX(isp)) {
4258 if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
4259 isp_intr(isp, isr, sema, mbox);
4260 }
4261 }
4262 return (CMD_QUEUED);
4263}
4264
4265/*
4266 * isp control
4267 * Locks (ints blocked) assumed held.
4268 */
4269
4270int
4271isp_control(ispsoftc_t *isp, ispctl_t ctl, void *arg)
4272{
4273 XS_T *xs;
4274 mbreg_t mbs;
4275 int bus, tgt;
4276 uint32_t handle;
4277
4278 MEMZERO(&mbs, sizeof (mbs));
4279
4280 switch (ctl) {
4281 default:
4282 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
4283 break;
4284
4285 case ISPCTL_RESET_BUS:
4286 /*
4287 * Issue a bus reset.
4288 */
4289 if (IS_24XX(isp)) {
4290 isp_prt(isp, ISP_LOGWARN, "RESET BUS NOT IMPLETENTED");
4291 break;
4292 } else if (IS_FC(isp)) {
4293 mbs.param[1] = 10;
4294 bus = 0;
4295 } else {
4296 mbs.param[1] = SDPARAM(isp)->isp_bus_reset_delay;
4297 if (mbs.param[1] < 2) {
4298 mbs.param[1] = 2;
4299 }
4300 bus = *((int *) arg);
4301 if (IS_DUALBUS(isp)) {
4302 mbs.param[2] = bus;
4303 }
4304 }
4305 mbs.param[0] = MBOX_BUS_RESET;
4306 isp->isp_sendmarker |= (1 << bus);
4307 mbs.logval = MBLOGALL;
4308 isp_mboxcmd(isp, &mbs);
4309 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4310 break;
4311 }
4312 isp_prt(isp, ISP_LOGINFO,
4313 "driver initiated bus reset of bus %d", bus);
4314 return (0);
4315
4316 case ISPCTL_RESET_DEV:
4317 tgt = (*((int *) arg)) & 0xffff;
4318 if (IS_24XX(isp)) {
4319 isp_prt(isp, ISP_LOGWARN, "RESET DEV NOT IMPLETENTED");
4320 break;
4321 } else if (IS_FC(isp)) {
4322 if (FCPARAM(isp)->isp_2klogin) {
4323 mbs.param[1] = tgt;
4324 mbs.ibits = (1 << 10);
4325 } else {
4326 mbs.param[1] = (tgt << 8);
4327 }
4328 bus = 0;
4329 } else {
4330 bus = (*((int *) arg)) >> 16;
4331 mbs.param[1] = (bus << 15) | (tgt << 8);
4332 }
4333 mbs.param[0] = MBOX_ABORT_TARGET;
4334 mbs.param[2] = 3; /* 'delay', in seconds */
4335 mbs.logval = MBLOGALL;
4336 isp_mboxcmd(isp, &mbs);
4337 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4338 break;
4339 }
4340 isp_prt(isp, ISP_LOGINFO,
4341 "Target %d on Bus %d Reset Succeeded", tgt, bus);
4342 isp->isp_sendmarker |= (1 << bus);
4343 return (0);
4344
4345 case ISPCTL_ABORT_CMD:
4346 xs = (XS_T *) arg;
4347 tgt = XS_TGT(xs);
4348
4349 handle = isp_find_handle(isp, xs);
4350 if (handle == 0) {
4351 isp_prt(isp, ISP_LOGWARN,
4352 "cannot find handle for command to abort");
4353 break;
4354 }
4355 if (IS_24XX(isp)) {
4356 isp_prt(isp, ISP_LOGWARN, "ABORT CMD NOT IMPLETENTED");
4357 break;
4358 } else if (IS_FC(isp)) {
4359 if (FCPARAM(isp)->isp_sccfw) {
4360 if (FCPARAM(isp)->isp_2klogin) {
4361 mbs.param[1] = tgt;
4362 } else {
4363 mbs.param[1] = tgt << 8;
4364 }
4365 mbs.param[6] = XS_LUN(xs);
4366 } else {
4367 mbs.param[1] = tgt << 8 | XS_LUN(xs);
4368 }
4369 } else {
4370 bus = XS_CHANNEL(xs);
4371 mbs.param[1] = (bus << 15) | (tgt << 8) | XS_LUN(xs);
4372 }
4373 mbs.param[0] = MBOX_ABORT;
4374 mbs.param[2] = handle;
4375 mbs.logval = MBLOGALL & ~MBOX_COMMAND_ERROR;
4376 isp_mboxcmd(isp, &mbs);
4377 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4378 break;
4379 }
4380 return (0);
4381
4382 case ISPCTL_UPDATE_PARAMS:
4383
4384 isp_update(isp);
4385 return (0);
4386
4387 case ISPCTL_FCLINK_TEST:
4388
4389 if (IS_FC(isp)) {
4390 int usdelay = *((int *) arg);
4391 if (usdelay == 0) {
4392 usdelay = 250000;
4393 }
4394 return (isp_fclink_test(isp, usdelay));
4395 }
4396 break;
4397
4398 case ISPCTL_SCAN_FABRIC:
4399
4400 if (IS_FC(isp)) {
4401 return (isp_scan_fabric(isp));
4402 }
4403 break;
4404
4405 case ISPCTL_SCAN_LOOP:
4406
4407 if (IS_FC(isp)) {
4408 return (isp_scan_loop(isp));
4409 }
4410 break;
4411
4412 case ISPCTL_PDB_SYNC:
4413
4414 if (IS_FC(isp)) {
4415 return (isp_pdb_sync(isp));
4416 }
4417 break;
4418
4419 case ISPCTL_SEND_LIP:
4420
4421 if (IS_FC(isp) && !IS_24XX(isp)) {
4422 mbs.param[0] = MBOX_INIT_LIP;
4423 if (FCPARAM(isp)->isp_2klogin) {
4424 mbs.ibits = (1 << 10);
4425 }
4426 mbs.logval = MBLOGALL;
4427 isp_mboxcmd(isp, &mbs);
4428 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
4429 return (0);
4430 }
4431 }
4432 break;
4433
4434 case ISPCTL_GET_PDB:
4435 if (IS_FC(isp) && arg) {
4436 int id = *((int *)arg);
4437 isp_pdb_t *pdb = arg;
4438 return (isp_getpdb(isp, id, pdb, 1));
4439 }
4440 break;
4441
4442 case ISPCTL_GET_PORTNAME:
4443 {
4444 uint64_t *wwnp = arg;
4445 int loopid = *wwnp;
4446 *wwnp = isp_get_portname(isp, loopid, 0);
4447 if (*wwnp == (uint64_t) -1) {
4448 break;
4449 } else {
4450 return (0);
4451 }
4452 }
4453 case ISPCTL_RUN_MBOXCMD:
4454
4455 isp_mboxcmd(isp, arg);
4456 return(0);
4457
4458 case ISPCTL_PLOGX:
4459 {
4460 isp_plcmd_t *p = arg;
4461 int r;
4462
4463 if ((p->flags & PLOGX_FLG_CMD_MASK) != PLOGX_FLG_CMD_PLOGI ||
4464 (p->handle != NIL_HANDLE)) {
4465 return (isp_plogx(isp, p->handle, p->portid,
4466 p->flags, 0));
4467 }
4468 do {
4469 p->handle = isp_nxt_handle(isp, p->handle);
4470 r = isp_plogx(isp, p->handle, p->portid, p->flags, 0);
4471 if ((r & 0xffff) == MBOX_PORT_ID_USED) {
4472 p->handle = r >> 16;
4473 r = 0;
4474 break;
4475 }
4476 } while ((r & 0xffff) == MBOX_LOOP_ID_USED);
4477 return (r);
4478 }
4479#ifdef ISP_TARGET_MODE
4480 case ISPCTL_TOGGLE_TMODE:
4481 {
4482
4483 /*
4484 * We don't check/set against role here- that's the
4485 * responsibility for the outer layer to coordinate.
4486 */
4487 if (IS_SCSI(isp)) {
4488 int param = *(int *)arg;
4489 mbs.param[0] = MBOX_ENABLE_TARGET_MODE;
4490 mbs.param[1] = param & 0xffff;
4491 mbs.param[2] = param >> 16;
4492 mbs.logval = MBLOGALL;
4493 isp_mboxcmd(isp, &mbs);
4494 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4495 break;
4496 }
4497 }
4498 return (0);
4499 }
4500#endif
4501 }
4502 return (-1);
4503}
4504
4505/*
4506 * Interrupt Service Routine(s).
4507 *
4508 * External (OS) framework has done the appropriate locking,
4509 * and the locking will be held throughout this function.
4510 */
4511
4512/*
4513 * Limit our stack depth by sticking with the max likely number
4514 * of completions on a request queue at any one time.
4515 */
4516#ifndef MAX_REQUESTQ_COMPLETIONS
4517#define MAX_REQUESTQ_COMPLETIONS 32
4518#endif
4519
4520void
4521isp_intr(ispsoftc_t *isp, uint32_t isr, uint16_t sema, uint16_t mbox)
4522{
4523 XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
4524 uint32_t iptr, optr, junk;
4525 int i, nlooked = 0, ndone = 0;
4526
4527again:
4528 optr = isp->isp_residx;
4529 /*
4530 * Is this a mailbox related interrupt?
4531 * The mailbox semaphore will be nonzero if so.
4532 */
4533 if (sema) {
4534 if (mbox & 0x4000) {
4535 isp->isp_intmboxc++;
4536 if (isp->isp_mboxbsy) {
4537 int i = 0, obits = isp->isp_obits;
4538 isp->isp_mboxtmp[i++] = mbox;
4539 for (i = 1; i < MAX_MAILBOX(isp); i++) {
4540 if ((obits & (1 << i)) == 0) {
4541 continue;
4542 }
4543 isp->isp_mboxtmp[i] =
4544 ISP_READ(isp, MBOX_OFF(i));
4545 }
4546 if (isp->isp_mbxwrk0) {
4547 if (isp_mbox_continue(isp) == 0) {
4548 return;
4549 }
4550 }
4551 MBOX_NOTIFY_COMPLETE(isp);
4552 } else {
4553 isp_prt(isp, ISP_LOGWARN,
4554 "mailbox cmd (0x%x) with no waiters", mbox);
4555 }
4556 } else if (isp_parse_async(isp, mbox) < 0) {
4557 return;
4558 }
4559 if ((IS_FC(isp) && mbox != ASYNC_RIO_RESP) ||
4560 isp->isp_state != ISP_RUNSTATE) {
4561 goto out;
|
4579 return;
| |
4580 }
4581 }
4582
4583 /*
4584 * We can't be getting this now.
4585 */
4586 if (isp->isp_state != ISP_RUNSTATE) {
4587 isp_prt(isp, ISP_LOGINFO,
4588 "interrupt (ISR=%x SEMA=%x) when not ready", isr, sema);
4589 /*
4590 * Thank you very much! *Burrrp*!
4591 */
4592 ISP_WRITE(isp, isp->isp_respoutrp,
4593 ISP_READ(isp, isp->isp_respinrp));
4594 if (IS_24XX(isp)) {
4595 ISP_DISABLE_INTS(isp);
4596 }
4597 goto out;
4598 }
4599
4600#ifdef ISP_TARGET_MODE
4601 /*
4602 * Check for ATIO Queue entries.
4603 */
4604 if (isp->isp_rspbsy == 0 && (isp->isp_role & ISP_ROLE_TARGET) &&
4605 IS_24XX(isp)) {
4606 iptr = ISP_READ(isp, isp->isp_atioinrp);
4607 optr = ISP_READ(isp, isp->isp_atiooutrp);
4608
4609 isp->isp_rspbsy = 1;
4610 while (optr != iptr) {
4611 uint8_t qe[QENTRY_LEN];
4612 isphdr_t *hp;
4613 uint32_t oop;
4614 void *addr;
4615
4616 oop = optr;
4617 MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN);
4618 addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
4619 isp_get_hdr(isp, addr, (isphdr_t *)qe);
4620 hp = (isphdr_t *)qe;
4621 switch (hp->rqs_entry_type) {
4622 case RQSTYPE_NOTIFY:
4623 case RQSTYPE_ATIO:
4624 (void) isp_target_notify(isp, addr, &oop);
4625 break;
4626 default:
4627 isp_print_qentry(isp, "?ATIOQ entry?",
4628 oop, addr);
4629 break;
4630 }
4631 optr = ISP_NXT_QENTRY(oop, RESULT_QUEUE_LEN(isp));
4632 ISP_WRITE(isp, isp->isp_atiooutrp, optr);
4633 }
4634 isp->isp_rspbsy = 0;
4635 }
4636#endif
4637
4638 /*
4639 * Get the current Response Queue Out Pointer.
4640 *
4641 * If we're a 2300 or 2400, we can ask what hardware what it thinks.
4642 */
4643 if (IS_23XX(isp) || IS_24XX(isp)) {
4644 optr = ISP_READ(isp, isp->isp_respoutrp);
4645 /*
4646 * Debug: to be taken out eventually
4647 */
4648 if (isp->isp_residx != optr) {
4649 isp_prt(isp, ISP_LOGINFO,
4650 "isp_intr: hard optr=%x, soft optr %x",
4651 optr, isp->isp_residx);
4652 isp->isp_residx = optr;
4653 }
4654 } else {
4655 optr = isp->isp_residx;
4656 }
4657
4658 /*
4659 * You *must* read the Response Queue In Pointer
4660 * prior to clearing the RISC interrupt.
4661 *
4662 * Debounce the 2300 if revision less than 2.
4663 */
4664 if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
4665 i = 0;
4666 do {
4667 iptr = ISP_READ(isp, isp->isp_respinrp);
4668 junk = ISP_READ(isp, isp->isp_respinrp);
4669 } while (junk != iptr && ++i < 1000);
4670
4671 if (iptr != junk) {
4672 isp_prt(isp, ISP_LOGWARN,
4673 "Response Queue Out Pointer Unstable (%x, %x)",
4674 iptr, junk);
4675 goto out;
4676 }
4677 } else {
4678 iptr = ISP_READ(isp, isp->isp_respinrp);
4679 }
4680 isp->isp_resodx = iptr;
4681
4682
4683 if (optr == iptr && sema == 0) {
4684 /*
4685 * There are a lot of these- reasons unknown- mostly on
4686 * faster Alpha machines.
4687 *
4688 * I tried delaying after writing HCCR_CMD_CLEAR_RISC_INT to
4689 * make sure the old interrupt went away (to avoid 'ringing'
4690 * effects), but that didn't stop this from occurring.
4691 */
4692 if (IS_24XX(isp)) {
4693 junk = 0;
4694 } else if (IS_23XX(isp)) {
4695 USEC_DELAY(100);
4696 iptr = ISP_READ(isp, isp->isp_respinrp);
4697 junk = ISP_READ(isp, BIU_R2HSTSLO);
4698 } else {
4699 junk = ISP_READ(isp, BIU_ISR);
4700 }
4701 if (optr == iptr) {
4702 if (IS_23XX(isp) || IS_24XX(isp)) {
4703 ;
4704 } else {
4705 sema = ISP_READ(isp, BIU_SEMA);
4706 mbox = ISP_READ(isp, OUTMAILBOX0);
4707 if ((sema & 0x3) && (mbox & 0x8000)) {
4708 goto again;
4709 }
4710 }
4711 isp->isp_intbogus++;
4712 isp_prt(isp, ISP_LOGDEBUG1,
4713 "bogus intr- isr %x (%x) iptr %x optr %x",
4714 isr, junk, iptr, optr);
4715 }
4716 }
4717 isp->isp_resodx = iptr;
4718
4719
4720 if (isp->isp_rspbsy) {
4721 goto out;
4722 }
4723 isp->isp_rspbsy = 1;
4724 while (optr != iptr) {
4725 uint8_t qe[QENTRY_LEN];
4726 ispstatusreq_t *sp = (ispstatusreq_t *) qe;
4727 isphdr_t *hp;
4728 int buddaboom, etype, scsi_status, completion_status;
4729 int req_status_flags, req_state_flags;
4730 uint8_t *snsp, *resp;
4731 uint32_t rlen, slen;
4732 long resid;
4733 uint16_t oop;
4734
4735 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
4736 oop = optr;
4737 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
4738 nlooked++;
4739 read_again:
4740 buddaboom = req_status_flags = req_state_flags = 0;
4741 resid = 0L;
4742
4743 /*
4744 * Synchronize our view of this response queue entry.
4745 */
4746 MEMORYBARRIER(isp, SYNC_RESULT, oop, QENTRY_LEN);
4747 isp_get_hdr(isp, hp, &sp->req_header);
4748 etype = sp->req_header.rqs_entry_type;
4749
4750 if (IS_24XX(isp) && etype == RQSTYPE_T7RQS) {
4751 isp24xx_statusreq_t *sp2 = (isp24xx_statusreq_t *)qe;
4752 isp_get_24xx_response(isp,
4753 (isp24xx_statusreq_t *)hp, sp2);
4754 if (isp->isp_dblev & ISP_LOGDEBUG1) {
4755 isp_print_bytes(isp,
4756 "Response Queue Entry", QENTRY_LEN, sp2);
4757 }
4758 scsi_status = sp2->req_scsi_status;
4759 completion_status = sp2->req_completion_status;
4760 req_state_flags = 0;
4761 resid = sp2->req_resid;
4762 } else if (etype == RQSTYPE_RESPONSE) {
4763 isp_get_response(isp, (ispstatusreq_t *) hp, sp);
4764 if (isp->isp_dblev & ISP_LOGDEBUG1) {
4765 isp_print_bytes(isp,
4766 "Response Queue Entry", QENTRY_LEN, sp);
4767 }
4768 scsi_status = sp->req_scsi_status;
4769 completion_status = sp->req_completion_status;
4770 req_status_flags = sp->req_status_flags;
4771 req_state_flags = sp->req_state_flags;
4772 resid = sp->req_resid;
4773 } else if (etype == RQSTYPE_RIO2) {
4774 isp_rio2_t *rio = (isp_rio2_t *)qe;
4775 isp_get_rio2(isp, (isp_rio2_t *) hp, rio);
4776 if (isp->isp_dblev & ISP_LOGDEBUG1) {
4777 isp_print_bytes(isp,
4778 "Response Queue Entry", QENTRY_LEN, rio);
4779 }
4780 for (i = 0; i < rio->req_header.rqs_seqno; i++) {
4781 isp_fastpost_complete(isp, rio->req_handles[i]);
4782 }
4783 if (isp->isp_fpcchiwater < rio->req_header.rqs_seqno) {
4784 isp->isp_fpcchiwater =
4785 rio->req_header.rqs_seqno;
4786 }
4787 MEMZERO(hp, QENTRY_LEN); /* PERF */
4788 continue;
4789 } else {
4790 /*
4791 * Somebody reachable via isp_handle_other_response
4792 * may have updated the response queue pointers for
4793 * us, so we reload our goal index.
4794 */
4795 int r;
4796 r = isp_handle_other_response(isp, etype, hp, &optr);
4797 if (r < 0) {
4798 goto read_again;
4799 }
4800 if (r > 0) {
4801 iptr = isp->isp_resodx;
4802 MEMZERO(hp, QENTRY_LEN); /* PERF */
4803 continue;
4804 }
4805
4806 /*
4807 * After this point, we'll just look at the header as
4808 * we don't know how to deal with the rest of the
4809 * response.
4810 */
4811
4812 /*
4813 * It really has to be a bounced request just copied
4814 * from the request queue to the response queue. If
4815 * not, something bad has happened.
4816 */
4817 if (etype != RQSTYPE_REQUEST) {
4818 isp_prt(isp, ISP_LOGERR, notresp,
4819 etype, oop, optr, nlooked);
4820 isp_print_bytes(isp,
4821 "Reqeonse Queue Entry", QENTRY_LEN, sp);
4822 MEMZERO(hp, QENTRY_LEN); /* PERF */
4823 continue;
4824 }
4825 buddaboom = 1;
4826 scsi_status = sp->req_scsi_status;
4827 completion_status = sp->req_completion_status;
4828 req_status_flags = sp->req_status_flags;
4829 req_state_flags = sp->req_state_flags;
4830 resid = sp->req_resid;
4831 }
4832
4833 if (sp->req_header.rqs_flags & RQSFLAG_MASK) {
4834 if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
4835 isp_prt(isp, ISP_LOGWARN,
4836 "continuation segment");
4837 ISP_WRITE(isp, isp->isp_respoutrp, optr);
4838 continue;
4839 }
4840 if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
4841 isp_prt(isp, ISP_LOGDEBUG1,
4842 "internal queues full");
4843 /*
4844 * We'll synthesize a QUEUE FULL message below.
4845 */
4846 }
4847 if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
4848 isp_print_bytes(isp, "bad header flag",
4849 QENTRY_LEN, sp);
4850 buddaboom++;
4851 }
4852 if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
4853 isp_print_bytes(isp, "bad request packet",
4854 QENTRY_LEN, sp);
4855 buddaboom++;
4856 }
4857 }
4858
4859 if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) {
4860 isp_prt(isp, ISP_LOGERR,
4861 "bad request handle %d (type 0x%x)",
4862 sp->req_handle, etype);
4863 MEMZERO(hp, QENTRY_LEN); /* PERF */
4864 ISP_WRITE(isp, isp->isp_respoutrp, optr);
4865 continue;
4866 }
4867 xs = isp_find_xs(isp, sp->req_handle);
4868 if (xs == NULL) {
4869 uint8_t ts = completion_status & 0xff;
4870 /*
4871 * Only whine if this isn't the expected fallout of
4872 * aborting the command.
4873 */
4874 if (etype != RQSTYPE_RESPONSE) {
4875 isp_prt(isp, ISP_LOGERR,
4876 "cannot find handle 0x%x (type 0x%x)",
4877 sp->req_handle, etype);
4878 } else if (ts != RQCS_ABORTED) {
4879 isp_prt(isp, ISP_LOGERR,
4880 "cannot find handle 0x%x (status 0x%x)",
4881 sp->req_handle, ts);
4882 }
4883 MEMZERO(hp, QENTRY_LEN); /* PERF */
4884 ISP_WRITE(isp, isp->isp_respoutrp, optr);
4885 continue;
4886 }
4887 isp_destroy_handle(isp, sp->req_handle);
4888 if (req_status_flags & RQSTF_BUS_RESET) {
4889 XS_SETERR(xs, HBA_BUSRESET);
4890 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
4891 }
4892 if (buddaboom) {
4893 XS_SETERR(xs, HBA_BOTCH);
4894 }
4895
4896 resp = NULL;
4897 rlen = 0;
4898 snsp = NULL;
4899 slen = 0;
4900 if (IS_24XX(isp) && (scsi_status & RQCS_RV) != 0) {
4901 resp = ((isp24xx_statusreq_t *)sp)->req_rsp_sense;
4902 rlen = ((isp24xx_statusreq_t *)sp)->req_response_len;
4903 } else if (IS_FC(isp) && (scsi_status & RQCS_RV) != 0) {
4904 resp = sp->req_response;
4905 rlen = sp->req_response_len;
4906 }
4907 if (IS_FC(isp) && (scsi_status & RQCS_SV) != 0) {
4908 /*
4909 * Fibre Channel F/W doesn't say we got status
4910 * if there's Sense Data instead. I guess they
4911 * think it goes w/o saying.
4912 */
4913 req_state_flags |= RQSF_GOT_STATUS|RQSF_GOT_SENSE;
4914 if (IS_24XX(isp)) {
4915 snsp =
4916 ((isp24xx_statusreq_t *)sp)->req_rsp_sense;
4917 snsp += rlen;
4918 slen =
4919 ((isp24xx_statusreq_t *)sp)->req_sense_len;
4920 } else {
4921 snsp = sp->req_sense_data;
4922 slen = sp->req_sense_len;
4923 }
4924 } else if (IS_SCSI(isp) && (req_state_flags & RQSF_GOT_SENSE)) {
4925 snsp = sp->req_sense_data;
4926 slen = sp->req_sense_len;
4927 }
4928 if (req_state_flags & RQSF_GOT_STATUS) {
4929 *XS_STSP(xs) = scsi_status & 0xff;
4930 }
4931
4932 switch (etype) {
4933 case RQSTYPE_RESPONSE:
4934 XS_SET_STATE_STAT(isp, xs, sp);
4935 if (resp && rlen >= 4 &&
4936 resp[FCP_RSPNS_CODE_OFFSET] != 0) {
4937 isp_prt(isp, ISP_LOGWARN,
4938 "%d.%d FCP RESPONSE: 0x%x",
4939 XS_TGT(xs), XS_LUN(xs),
4940 resp[FCP_RSPNS_CODE_OFFSET]);
4941 XS_SETERR(xs, HBA_BOTCH);
4942 }
4943 if (IS_24XX(isp)) {
4944 isp_parse_status_24xx(isp,
4945 (isp24xx_statusreq_t *)sp, xs, &resid);
4946 } else {
4947 isp_parse_status(isp, (void *)sp, xs, &resid);
4948 }
4949 if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
4950 (*XS_STSP(xs) == SCSI_BUSY)) {
4951 XS_SETERR(xs, HBA_TGTBSY);
4952 }
4953 if (IS_SCSI(isp)) {
4954 XS_RESID(xs) = resid;
4955 /*
4956 * A new synchronous rate was negotiated for
4957 * this target. Mark state such that we'll go
4958 * look up that which has changed later.
4959 */
4960 if (req_status_flags & RQSTF_NEGOTIATION) {
4961 int t = XS_TGT(xs);
4962 sdparam *sdp = isp->isp_param;
4963 sdp += XS_CHANNEL(xs);
4964 sdp->isp_devparam[t].dev_refresh = 1;
4965 isp->isp_update |=
4966 (1 << XS_CHANNEL(xs));
4967 }
4968 } else {
4969 if (req_status_flags & RQSF_XFER_COMPLETE) {
4970 XS_RESID(xs) = 0;
4971 } else if (scsi_status & RQCS_RESID) {
4972 XS_RESID(xs) = resid;
4973 } else {
4974 XS_RESID(xs) = 0;
4975 }
4976 }
4977 if (snsp && slen) {
4978 XS_SAVE_SENSE(xs, snsp, slen);
4979 }
4980 isp_prt(isp, ISP_LOGDEBUG2,
4981 "asked for %ld got raw resid %ld settled for %ld",
4982 (long) XS_XFRLEN(xs), resid, (long) XS_RESID(xs));
4983 break;
4984 case RQSTYPE_REQUEST:
4985 case RQSTYPE_A64:
4986 case RQSTYPE_T2RQS:
4987 case RQSTYPE_T3RQS:
4988 case RQSTYPE_T7RQS:
4989 if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
4990 /*
4991 * Force Queue Full status.
4992 */
4993 *XS_STSP(xs) = SCSI_QFULL;
4994 XS_SETERR(xs, HBA_NOERROR);
4995 } else if (XS_NOERR(xs)) {
4996 /*
4997 * ????
4998 */
4999 XS_SETERR(xs, HBA_BOTCH);
5000 isp_prt(isp, ISP_LOGDEBUG0,
5001 "Request Queue Entry bounced back");
5002 if ((isp->isp_dblev & ISP_LOGDEBUG1) == 0) {
5003 isp_print_bytes(isp, "Bounced Request",
5004 QENTRY_LEN, qe);
5005 }
5006 }
5007 XS_RESID(xs) = XS_XFRLEN(xs);
5008 break;
5009 default:
5010 isp_print_bytes(isp, "Unhandled Response Type",
5011 QENTRY_LEN, qe);
5012 if (XS_NOERR(xs)) {
5013 XS_SETERR(xs, HBA_BOTCH);
5014 }
5015 break;
5016 }
5017
5018 /*
5019 * Free any DMA resources. As a side effect, this may
5020 * also do any cache flushing necessary for data coherence. */
5021 if (XS_XFRLEN(xs)) {
5022 ISP_DMAFREE(isp, xs, sp->req_handle);
5023 }
5024
5025 if (((isp->isp_dblev & (ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
5026 ((isp->isp_dblev & ISP_LOGDEBUG1) && ((!XS_NOERR(xs)) ||
5027 (*XS_STSP(xs) != SCSI_GOOD)))) {
5028 char skey;
5029 if (req_state_flags & RQSF_GOT_SENSE) {
5030 skey = XS_SNSKEY(xs) & 0xf;
5031 if (skey < 10)
5032 skey += '0';
5033 else
5034 skey += 'a' - 10;
5035 } else if (*XS_STSP(xs) == SCSI_CHECK) {
5036 skey = '?';
5037 } else {
5038 skey = '.';
5039 }
5040 isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs),
5041 XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs), XS_RESID(xs),
5042 *XS_STSP(xs), skey, XS_ERR(xs));
5043 }
5044
5045 if (isp->isp_nactive > 0)
5046 isp->isp_nactive--;
5047 complist[ndone++] = xs; /* defer completion call until later */
5048 MEMZERO(hp, QENTRY_LEN); /* PERF */
5049 if (ndone == MAX_REQUESTQ_COMPLETIONS) {
5050 break;
5051 }
5052 }
5053
5054 /*
5055 * If we looked at any commands, then it's valid to find out
5056 * what the outpointer is. It also is a trigger to update the
5057 * ISP's notion of what we've seen so far.
5058 */
5059 if (nlooked) {
5060 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5061 /*
5062 * While we're at it, read the requst queue out pointer.
5063 */
5064 isp->isp_reqodx = ISP_READ(isp, isp->isp_rqstoutrp);
5065 if (isp->isp_rscchiwater < ndone) {
5066 isp->isp_rscchiwater = ndone;
5067 }
5068 }
5069
5070out:
5071
5072 if (IS_24XX(isp)) {
5073 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
5074 } else {
5075 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
5076 ISP_WRITE(isp, BIU_SEMA, 0);
5077 }
5078
5079 isp->isp_residx = optr;
5080 isp->isp_rspbsy = 0;
5081 for (i = 0; i < ndone; i++) {
5082 xs = complist[i];
5083 if (xs) {
5084 isp->isp_rsltccmplt++;
5085 isp_done(xs);
5086 }
5087 }
5088}
5089
5090/*
5091 * Support routines.
5092 */
5093
5094static int
5095isp_parse_async(ispsoftc_t *isp, uint16_t mbox)
5096{
5097 int rval = 0;
5098 int bus;
5099
5100 if (IS_DUALBUS(isp)) {
5101 bus = ISP_READ(isp, OUTMAILBOX6);
5102 } else {
5103 bus = 0;
5104 }
5105 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5106
5107 switch (mbox) {
5108 case ASYNC_BUS_RESET:
5109 isp->isp_sendmarker |= (1 << bus);
5110#ifdef ISP_TARGET_MODE
5111 if (isp_target_async(isp, bus, mbox)) {
5112 rval = -1;
5113 }
5114#endif
5115 isp_async(isp, ISPASYNC_BUS_RESET, &bus);
5116 break;
5117 case ASYNC_SYSTEM_ERROR:
5118 isp->isp_state = ISP_CRASHED;
5119 if (IS_FC(isp)) {
5120 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
5121 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5122 }
5123 /*
5124 * Were we waiting for a mailbox command to complete?
5125 * If so, it's dead, so wake up the waiter.
5126 */
5127 if (isp->isp_mboxbsy) {
5128 isp->isp_obits = 1;
5129 isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5130 MBOX_NOTIFY_COMPLETE(isp);
5131 }
5132#ifdef ISP_FW_CRASH_DUMP
5133 /*
5134 * If we have crash dumps enabled, it's up to the handler
5135 * for isp_async to reinit stuff and restart the firmware
5136 * after performing the crash dump. The reason we do things
5137 * this way is that we may need to activate a kernel thread
5138 * to do all the crash dump goop.
5139 */
5140 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
5141#else
5142 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
5143 isp_reinit(isp);
5144 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
5145#endif
5146 rval = -1;
5147 break;
5148
5149 case ASYNC_RQS_XFER_ERR:
5150 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5151 break;
5152
5153 case ASYNC_RSP_XFER_ERR:
5154 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5155 break;
5156
5157 case ASYNC_QWAKEUP:
5158 /*
5159 * We've just been notified that the Queue has woken up.
5160 * We don't need to be chatty about this- just unlatch things
5161 * and move on.
5162 */
5163 mbox = ISP_READ(isp, isp->isp_rqstoutrp);
5164 break;
5165
5166 case ASYNC_TIMEOUT_RESET:
5167 isp_prt(isp, ISP_LOGWARN,
5168 "timeout initiated SCSI bus reset of bus %d", bus);
5169 isp->isp_sendmarker |= (1 << bus);
5170#ifdef ISP_TARGET_MODE
5171 if (isp_target_async(isp, bus, mbox)) {
5172 rval = -1;
5173 }
5174#endif
5175 break;
5176
5177 case ASYNC_DEVICE_RESET:
5178 isp_prt(isp, ISP_LOGINFO, "device reset on bus %d", bus);
5179 isp->isp_sendmarker |= (1 << bus);
5180#ifdef ISP_TARGET_MODE
5181 if (isp_target_async(isp, bus, mbox)) {
5182 rval = -1;
5183 }
5184#endif
5185 break;
5186
5187 case ASYNC_EXTMSG_UNDERRUN:
5188 isp_prt(isp, ISP_LOGWARN, "extended message underrun");
5189 break;
5190
5191 case ASYNC_SCAM_INT:
5192 isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
5193 break;
5194
5195 case ASYNC_HUNG_SCSI:
5196 isp_prt(isp, ISP_LOGERR,
5197 "stalled SCSI Bus after DATA Overrun");
5198 /* XXX: Need to issue SCSI reset at this point */
5199 break;
5200
5201 case ASYNC_KILLED_BUS:
5202 isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
5203 break;
5204
5205 case ASYNC_BUS_TRANSIT:
5206 mbox = ISP_READ(isp, OUTMAILBOX2);
5207 switch (mbox & 0x1c00) {
5208 case SXP_PINS_LVD_MODE:
5209 isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
5210 SDPARAM(isp)->isp_diffmode = 0;
5211 SDPARAM(isp)->isp_ultramode = 0;
5212 SDPARAM(isp)->isp_lvdmode = 1;
5213 break;
5214 case SXP_PINS_HVD_MODE:
5215 isp_prt(isp, ISP_LOGINFO,
5216 "Transition to Differential mode");
5217 SDPARAM(isp)->isp_diffmode = 1;
5218 SDPARAM(isp)->isp_ultramode = 0;
5219 SDPARAM(isp)->isp_lvdmode = 0;
5220 break;
5221 case SXP_PINS_SE_MODE:
5222 isp_prt(isp, ISP_LOGINFO,
5223 "Transition to Single Ended mode");
5224 SDPARAM(isp)->isp_diffmode = 0;
5225 SDPARAM(isp)->isp_ultramode = 1;
5226 SDPARAM(isp)->isp_lvdmode = 0;
5227 break;
5228 default:
5229 isp_prt(isp, ISP_LOGWARN,
5230 "Transition to Unknown Mode 0x%x", mbox);
5231 break;
5232 }
5233 /*
5234 * XXX: Set up to renegotiate again!
5235 */
5236 /* Can only be for a 1080... */
5237 isp->isp_sendmarker |= (1 << bus);
5238 break;
5239
5240 /*
5241 * We can use bus, which will always be zero for FC cards,
5242 * as a mailbox pattern accumulator to be checked below.
5243 */
5244 case ASYNC_RIO5:
5245 bus = 0x1ce; /* outgoing mailbox regs 1-3, 6-7 */
5246 break;
5247
5248 case ASYNC_RIO4:
5249 bus = 0x14e; /* outgoing mailbox regs 1-3, 6 */
5250 break;
5251
5252 case ASYNC_RIO3:
5253 bus = 0x10e; /* outgoing mailbox regs 1-3 */
5254 break;
5255
5256 case ASYNC_RIO2:
5257 bus = 0x106; /* outgoing mailbox regs 1-2 */
5258 break;
5259
5260 case ASYNC_RIO1:
5261 case ASYNC_CMD_CMPLT:
5262 bus = 0x102; /* outgoing mailbox regs 1 */
5263 break;
5264
5265 case ASYNC_RIO_RESP:
5266 return (rval);
5267
5268 case ASYNC_CTIO_DONE:
5269 {
5270#ifdef ISP_TARGET_MODE
5271 int handle =
5272 (ISP_READ(isp, OUTMAILBOX2) << 16) |
5273 (ISP_READ(isp, OUTMAILBOX1));
5274 if (isp_target_async(isp, handle, mbox)) {
5275 rval = -1;
5276 } else {
5277 /* count it as a fast posting intr */
5278 isp->isp_fphccmplt++;
5279 }
5280#else
5281 isp_prt(isp, ISP_LOGINFO, "Fast Posting CTIO done");
5282 isp->isp_fphccmplt++; /* count it as a fast posting intr */
5283#endif
5284 break;
5285 }
5286 case ASYNC_LIP_ERROR:
5287 case ASYNC_LIP_F8:
5288 case ASYNC_LIP_OCCURRED:
5289 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5290 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
5291 isp->isp_sendmarker = 1;
5292 ISP_MARK_PORTDB(isp, 1);
5293 isp_async(isp, ISPASYNC_LIP, NULL);
5294#ifdef ISP_TARGET_MODE
5295 if (isp_target_async(isp, bus, mbox)) {
5296 rval = -1;
5297 }
5298#endif
5299 /*
5300 * We've had problems with data corruption occuring on
5301 * commands that complete (with no apparent error) after
5302 * we receive a LIP. This has been observed mostly on
5303 * Local Loop topologies. To be safe, let's just mark
5304 * all active commands as dead.
5305 */
5306 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
5307 FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
5308 int i, j;
5309 for (i = j = 0; i < isp->isp_maxcmds; i++) {
5310 XS_T *xs;
5311 xs = isp->isp_xflist[i];
5312 if (xs != NULL) {
5313 j++;
5314 XS_SETERR(xs, HBA_BUSRESET);
5315 }
5316 }
5317 if (j) {
5318 isp_prt(isp, ISP_LOGERR,
5319 "LIP destroyed %d active commands", j);
5320 }
5321 }
5322 break;
5323
5324 case ASYNC_LOOP_UP:
5325 isp->isp_sendmarker = 1;
5326 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5327 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
5328 ISP_MARK_PORTDB(isp, 1);
5329 isp_async(isp, ISPASYNC_LOOP_UP, NULL);
5330#ifdef ISP_TARGET_MODE
5331 if (isp_target_async(isp, bus, mbox)) {
5332 rval = -1;
5333 }
5334#endif
5335 break;
5336
5337 case ASYNC_LOOP_DOWN:
5338 isp->isp_sendmarker = 1;
5339 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5340 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
5341 ISP_MARK_PORTDB(isp, 1);
5342 isp_async(isp, ISPASYNC_LOOP_DOWN, NULL);
5343#ifdef ISP_TARGET_MODE
5344 if (isp_target_async(isp, bus, mbox)) {
5345 rval = -1;
5346 }
5347#endif
5348 break;
5349
5350 case ASYNC_LOOP_RESET:
5351 isp->isp_sendmarker = 1;
5352 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5353 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
5354 ISP_MARK_PORTDB(isp, 1);
5355 isp_async(isp, ISPASYNC_LOOP_RESET, NULL);
5356#ifdef ISP_TARGET_MODE
5357 if (isp_target_async(isp, bus, mbox)) {
5358 rval = -1;
5359 }
5360#endif
5361 break;
5362
5363 case ASYNC_PDB_CHANGED:
5364 isp->isp_sendmarker = 1;
5365 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
5366 ISP_MARK_PORTDB(isp, 1);
5367 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_PDB);
5368 break;
5369
5370 case ASYNC_CHANGE_NOTIFY:
5371 if (FCPARAM(isp)->isp_topo == TOPO_F_PORT) {
5372 FCPARAM(isp)->isp_loopstate = LOOP_LSCAN_DONE;
5373 } else {
5374 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
5375 }
5376 ISP_MARK_PORTDB(isp, 1);
5377 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_SNS);
5378 break;
5379
5380 case ASYNC_PTPMODE:
5381 ISP_MARK_PORTDB(isp, 1);
5382 isp->isp_sendmarker = 1;
5383 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5384 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
5385 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
5386#ifdef ISP_TARGET_MODE
5387 if (isp_target_async(isp, bus, mbox)) {
5388 rval = -1;
5389 }
5390#endif
5391 isp_prt(isp, ISP_LOGINFO, "Point-to-Point mode");
5392 break;
5393
5394 case ASYNC_CONNMODE:
5395 mbox = ISP_READ(isp, OUTMAILBOX1);
5396 ISP_MARK_PORTDB(isp, 1);
5397 switch (mbox) {
5398 case ISP_CONN_LOOP:
5399 isp_prt(isp, ISP_LOGINFO,
5400 "Point-to-Point -> Loop mode");
5401 break;
5402 case ISP_CONN_PTP:
5403 isp_prt(isp, ISP_LOGINFO,
5404 "Loop -> Point-to-Point mode");
5405 break;
5406 case ISP_CONN_BADLIP:
5407 isp_prt(isp, ISP_LOGWARN,
5408 "Point-to-Point -> Loop mode (BAD LIP)");
5409 break;
5410 case ISP_CONN_FATAL:
5411 isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
5412#ifdef ISP_FW_CRASH_DUMP
5413 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
5414#else
5415 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
5416 isp_reinit(isp);
5417 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
5418#endif
5419 return (-1);
5420 case ISP_CONN_LOOPBACK:
5421 isp_prt(isp, ISP_LOGWARN,
5422 "Looped Back in Point-to-Point mode");
5423 break;
5424 default:
5425 isp_prt(isp, ISP_LOGWARN,
5426 "Unknown connection mode (0x%x)", mbox);
5427 break;
5428 }
5429 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
5430 isp->isp_sendmarker = 1;
5431 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5432 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
5433 break;
5434
5435 case ASYNC_RJT_SENT: /* same as ASYNC_QFULL_SENT */
5436 if (IS_24XX(isp)) {
5437 isp_prt(isp, ISP_LOGTDEBUG0, "LS_RJT sent");
5438 break;
5439 } else if (IS_2200(isp)) {
5440 isp_prt(isp, ISP_LOGTDEBUG0, "QFULL sent");
5441 break;
5442 }
5443 /* FALLTHROUGH */
5444 default:
5445 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
5446 break;
5447 }
5448
5449 if (bus & 0x100) {
5450 int i, nh;
5451 uint16_t handles[16];
5452
5453 for (nh = 0, i = 1; i < MAX_MAILBOX(isp); i++) {
5454 if ((bus & (1 << i)) == 0) {
5455 continue;
5456 }
5457 handles[nh++] = ISP_READ(isp, MBOX_OFF(i));
5458 }
5459 for (i = 0; i < nh; i++) {
5460 isp_fastpost_complete(isp, handles[i]);
5461 isp_prt(isp, ISP_LOGDEBUG3,
5462 "fast post completion of %u", handles[i]);
5463 }
5464 if (isp->isp_fpcchiwater < nh) {
5465 isp->isp_fpcchiwater = nh;
5466 }
5467 } else {
5468 isp->isp_intoasync++;
5469 }
5470 return (rval);
5471}
5472
5473/*
5474 * Handle other response entries. A pointer to the request queue output
5475 * index is here in case we want to eat several entries at once, although
5476 * this is not used currently.
5477 */
5478
5479static int
5480isp_handle_other_response(ispsoftc_t *isp, int type,
5481 isphdr_t *hp, uint32_t *optrp)
5482{
5483 switch (type) {
5484 case RQSTYPE_STATUS_CONT:
5485 isp_prt(isp, ISP_LOGDEBUG0, "Ignored Continuation Response");
5486 return (1);
5487 case RQSTYPE_MARKER:
5488 isp_prt(isp, ISP_LOGDEBUG0, "Marker Response");
5489 return (1);
5490 case RQSTYPE_ATIO:
5491 case RQSTYPE_CTIO:
5492 case RQSTYPE_ENABLE_LUN:
5493 case RQSTYPE_MODIFY_LUN:
5494 case RQSTYPE_NOTIFY:
5495 case RQSTYPE_NOTIFY_ACK:
5496 case RQSTYPE_CTIO1:
5497 case RQSTYPE_ATIO2:
5498 case RQSTYPE_CTIO2:
5499 case RQSTYPE_CTIO3:
5500 case RQSTYPE_CTIO7:
5501 case RQSTYPE_ABTS_RCVD:
5502 case RQSTYPE_ABTS_RSP:
5503 isp->isp_rsltccmplt++; /* count as a response completion */
5504#ifdef ISP_TARGET_MODE
5505 if (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp)) {
5506 return (1);
5507 }
5508#endif
5509 /* FALLTHROUGH */
5510 case RQSTYPE_REQUEST:
5511 default:
5512 USEC_DELAY(100);
5513 if (type != isp_get_response_type(isp, hp)) {
5514 /*
5515 * This is questionable- we're just papering over
5516 * something we've seen on SMP linux in target
5517 * mode- we don't really know what's happening
5518 * here that causes us to think we've gotten
5519 * an entry, but that either the entry isn't
5520 * filled out yet or our CPU read data is stale.
5521 */
5522 isp_prt(isp, ISP_LOGINFO,
5523 "unstable type in response queue");
5524 return (-1);
5525 }
5526 isp_prt(isp, ISP_LOGWARN, "Unhandled Response Type 0x%x",
5527 isp_get_response_type(isp, hp));
5528 if (isp_async(isp, ISPASYNC_UNHANDLED_RESPONSE, hp)) {
5529 return (1);
5530 }
5531 return (0);
5532 }
5533}
5534
5535static void
5536isp_parse_status(ispsoftc_t *isp, ispstatusreq_t *sp, XS_T *xs, long *rp)
5537{
5538 switch (sp->req_completion_status & 0xff) {
5539 case RQCS_COMPLETE:
5540 if (XS_NOERR(xs)) {
5541 XS_SETERR(xs, HBA_NOERROR);
5542 }
5543 return;
5544
5545 case RQCS_INCOMPLETE:
5546 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
5547 isp_prt(isp, ISP_LOGDEBUG1,
5548 "Selection Timeout for %d.%d.%d",
5549 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5550 if (XS_NOERR(xs)) {
5551 XS_SETERR(xs, HBA_SELTIMEOUT);
5552 *rp = XS_XFRLEN(xs);
5553 }
5554 return;
5555 }
5556 isp_prt(isp, ISP_LOGERR,
5557 "command incomplete for %d.%d.%d, state 0x%x",
5558 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
5559 sp->req_state_flags);
5560 break;
5561
5562 case RQCS_DMA_ERROR:
5563 isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
5564 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5565 *rp = XS_XFRLEN(xs);
5566 break;
5567
5568 case RQCS_TRANSPORT_ERROR:
5569 {
5570 char buf[172];
5571 SNPRINTF(buf, sizeof (buf), "states=>");
5572 if (sp->req_state_flags & RQSF_GOT_BUS) {
5573 SNPRINTF(buf, sizeof (buf), "%s GOT_BUS", buf);
5574 }
5575 if (sp->req_state_flags & RQSF_GOT_TARGET) {
5576 SNPRINTF(buf, sizeof (buf), "%s GOT_TGT", buf);
5577 }
5578 if (sp->req_state_flags & RQSF_SENT_CDB) {
5579 SNPRINTF(buf, sizeof (buf), "%s SENT_CDB", buf);
5580 }
5581 if (sp->req_state_flags & RQSF_XFRD_DATA) {
5582 SNPRINTF(buf, sizeof (buf), "%s XFRD_DATA", buf);
5583 }
5584 if (sp->req_state_flags & RQSF_GOT_STATUS) {
5585 SNPRINTF(buf, sizeof (buf), "%s GOT_STS", buf);
5586 }
5587 if (sp->req_state_flags & RQSF_GOT_SENSE) {
5588 SNPRINTF(buf, sizeof (buf), "%s GOT_SNS", buf);
5589 }
5590 if (sp->req_state_flags & RQSF_XFER_COMPLETE) {
5591 SNPRINTF(buf, sizeof (buf), "%s XFR_CMPLT", buf);
5592 }
5593 SNPRINTF(buf, sizeof (buf), "%s\nstatus=>", buf);
5594 if (sp->req_status_flags & RQSTF_DISCONNECT) {
5595 SNPRINTF(buf, sizeof (buf), "%s Disconnect", buf);
5596 }
5597 if (sp->req_status_flags & RQSTF_SYNCHRONOUS) {
5598 SNPRINTF(buf, sizeof (buf), "%s Sync_xfr", buf);
5599 }
5600 if (sp->req_status_flags & RQSTF_PARITY_ERROR) {
5601 SNPRINTF(buf, sizeof (buf), "%s Parity", buf);
5602 }
5603 if (sp->req_status_flags & RQSTF_BUS_RESET) {
5604 SNPRINTF(buf, sizeof (buf), "%s Bus_Reset", buf);
5605 }
5606 if (sp->req_status_flags & RQSTF_DEVICE_RESET) {
5607 SNPRINTF(buf, sizeof (buf), "%s Device_Reset", buf);
5608 }
5609 if (sp->req_status_flags & RQSTF_ABORTED) {
5610 SNPRINTF(buf, sizeof (buf), "%s Aborted", buf);
5611 }
5612 if (sp->req_status_flags & RQSTF_TIMEOUT) {
5613 SNPRINTF(buf, sizeof (buf), "%s Timeout", buf);
5614 }
5615 if (sp->req_status_flags & RQSTF_NEGOTIATION) {
5616 SNPRINTF(buf, sizeof (buf), "%s Negotiation", buf);
5617 }
5618 isp_prt(isp, ISP_LOGERR, "%s", buf);
5619 isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d:\n%s",
5620 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), buf);
5621 *rp = XS_XFRLEN(xs);
5622 break;
5623 }
5624 case RQCS_RESET_OCCURRED:
5625 isp_prt(isp, ISP_LOGWARN,
5626 "bus reset destroyed command for %d.%d.%d",
5627 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5628 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
5629 if (XS_NOERR(xs)) {
5630 XS_SETERR(xs, HBA_BUSRESET);
5631 }
5632 *rp = XS_XFRLEN(xs);
5633 return;
5634
5635 case RQCS_ABORTED:
5636 isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d",
5637 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5638 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
5639 if (XS_NOERR(xs)) {
5640 XS_SETERR(xs, HBA_ABORTED);
5641 }
5642 return;
5643
5644 case RQCS_TIMEOUT:
5645 isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
5646 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5647 /*
5648 * XXX: Check to see if we logged out of the device.
5649 */
5650 if (XS_NOERR(xs)) {
5651 XS_SETERR(xs, HBA_CMDTIMEOUT);
5652 }
5653 return;
5654
5655 case RQCS_DATA_OVERRUN:
5656 XS_RESID(xs) = sp->req_resid;
5657 isp_prt(isp, ISP_LOGERR, "data overrun for command on %d.%d.%d",
5658 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5659 if (XS_NOERR(xs)) {
5660 XS_SETERR(xs, HBA_DATAOVR);
5661 }
5662 return;
5663
5664 case RQCS_COMMAND_OVERRUN:
5665 isp_prt(isp, ISP_LOGERR,
5666 "command overrun for command on %d.%d.%d",
5667 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5668 break;
5669
5670 case RQCS_STATUS_OVERRUN:
5671 isp_prt(isp, ISP_LOGERR,
5672 "status overrun for command on %d.%d.%d",
5673 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5674 break;
5675
5676 case RQCS_BAD_MESSAGE:
5677 isp_prt(isp, ISP_LOGERR,
5678 "msg not COMMAND COMPLETE after status %d.%d.%d",
5679 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5680 break;
5681
5682 case RQCS_NO_MESSAGE_OUT:
5683 isp_prt(isp, ISP_LOGERR,
5684 "No MESSAGE OUT phase after selection on %d.%d.%d",
5685 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5686 break;
5687
5688 case RQCS_EXT_ID_FAILED:
5689 isp_prt(isp, ISP_LOGERR, "EXTENDED IDENTIFY failed %d.%d.%d",
5690 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5691 break;
5692
5693 case RQCS_IDE_MSG_FAILED:
5694 isp_prt(isp, ISP_LOGERR,
5695 "INITIATOR DETECTED ERROR rejected by %d.%d.%d",
5696 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5697 break;
5698
5699 case RQCS_ABORT_MSG_FAILED:
5700 isp_prt(isp, ISP_LOGERR, "ABORT OPERATION rejected by %d.%d.%d",
5701 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5702 break;
5703
5704 case RQCS_REJECT_MSG_FAILED:
5705 isp_prt(isp, ISP_LOGERR, "MESSAGE REJECT rejected by %d.%d.%d",
5706 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5707 break;
5708
5709 case RQCS_NOP_MSG_FAILED:
5710 isp_prt(isp, ISP_LOGERR, "NOP rejected by %d.%d.%d",
5711 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5712 break;
5713
5714 case RQCS_PARITY_ERROR_MSG_FAILED:
5715 isp_prt(isp, ISP_LOGERR,
5716 "MESSAGE PARITY ERROR rejected by %d.%d.%d",
5717 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5718 break;
5719
5720 case RQCS_DEVICE_RESET_MSG_FAILED:
5721 isp_prt(isp, ISP_LOGWARN,
5722 "BUS DEVICE RESET rejected by %d.%d.%d",
5723 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5724 break;
5725
5726 case RQCS_ID_MSG_FAILED:
5727 isp_prt(isp, ISP_LOGERR, "IDENTIFY rejected by %d.%d.%d",
5728 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5729 break;
5730
5731 case RQCS_UNEXP_BUS_FREE:
5732 isp_prt(isp, ISP_LOGERR, "%d.%d.%d had an unexpected bus free",
5733 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5734 break;
5735
5736 case RQCS_DATA_UNDERRUN:
5737 {
5738 if (IS_FC(isp)) {
5739 int ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
5740 if (!ru_marked || sp->req_resid > XS_XFRLEN(xs)) {
5741 isp_prt(isp, ISP_LOGWARN, bun, XS_TGT(xs),
5742 XS_LUN(xs), XS_XFRLEN(xs), sp->req_resid,
5743 (ru_marked)? "marked" : "not marked");
5744 if (XS_NOERR(xs)) {
5745 XS_SETERR(xs, HBA_BOTCH);
5746 }
5747 return;
5748 }
5749 }
5750 XS_RESID(xs) = sp->req_resid;
5751 if (XS_NOERR(xs)) {
5752 XS_SETERR(xs, HBA_NOERROR);
5753 }
5754 return;
5755 }
5756
5757 case RQCS_XACT_ERR1:
5758 isp_prt(isp, ISP_LOGERR, xact1, XS_CHANNEL(xs),
5759 XS_TGT(xs), XS_LUN(xs));
5760 break;
5761
5762 case RQCS_XACT_ERR2:
5763 isp_prt(isp, ISP_LOGERR, xact2,
5764 XS_LUN(xs), XS_TGT(xs), XS_CHANNEL(xs));
5765 break;
5766
5767 case RQCS_XACT_ERR3:
5768 isp_prt(isp, ISP_LOGERR, xact3,
5769 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5770 break;
5771
5772 case RQCS_BAD_ENTRY:
5773 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
5774 break;
5775
5776 case RQCS_QUEUE_FULL:
5777 isp_prt(isp, ISP_LOGDEBUG0,
5778 "internal queues full for %d.%d.%d status 0x%x",
5779 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), *XS_STSP(xs));
5780
5781 /*
5782 * If QFULL or some other status byte is set, then this
5783 * isn't an error, per se.
5784 *
5785 * Unfortunately, some QLogic f/w writers have, in
5786 * some cases, ommitted to *set* status to QFULL.
5787 *
5788
5789 if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
5790 XS_SETERR(xs, HBA_NOERROR);
5791 return;
5792 }
5793
5794 *
5795 *
5796 */
5797
5798 *XS_STSP(xs) = SCSI_QFULL;
5799 XS_SETERR(xs, HBA_NOERROR);
5800 return;
5801
5802 case RQCS_PHASE_SKIPPED:
5803 isp_prt(isp, ISP_LOGERR, pskip, XS_CHANNEL(xs),
5804 XS_TGT(xs), XS_LUN(xs));
5805 break;
5806
5807 case RQCS_ARQS_FAILED:
5808 isp_prt(isp, ISP_LOGERR,
5809 "Auto Request Sense failed for %d.%d.%d",
5810 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5811 if (XS_NOERR(xs)) {
5812 XS_SETERR(xs, HBA_ARQFAIL);
5813 }
5814 return;
5815
5816 case RQCS_WIDE_FAILED:
5817 isp_prt(isp, ISP_LOGERR,
5818 "Wide Negotiation failed for %d.%d.%d",
5819 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
5820 if (IS_SCSI(isp)) {
5821 sdparam *sdp = isp->isp_param;
5822 sdp += XS_CHANNEL(xs);
5823 sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_WIDE;
5824 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
5825 isp->isp_update |= (1 << XS_CHANNEL(xs));
5826 }
5827 if (XS_NOERR(xs)) {
5828 XS_SETERR(xs, HBA_NOERROR);
5829 }
5830 return;
5831
5832 case RQCS_SYNCXFER_FAILED:
5833 isp_prt(isp, ISP_LOGERR,
5834 "SDTR Message failed for target %d.%d.%d",
5835 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
5836 if (IS_SCSI(isp)) {
5837 sdparam *sdp = isp->isp_param;
5838 sdp += XS_CHANNEL(xs);
5839 sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_SYNC;
5840 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
5841 isp->isp_update |= (1 << XS_CHANNEL(xs));
5842 }
5843 break;
5844
5845 case RQCS_LVD_BUSERR:
5846 isp_prt(isp, ISP_LOGERR,
5847 "Bad LVD condition while talking to %d.%d.%d",
5848 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
5849 break;
5850
5851 case RQCS_PORT_UNAVAILABLE:
5852 /*
5853 * No such port on the loop. Moral equivalent of SELTIMEO
5854 */
5855 case RQCS_PORT_LOGGED_OUT:
5856 {
5857 char *reason;
5858 uint8_t sts = sp->req_completion_status & 0xff;
5859
5860 /*
5861 * It was there (maybe)- treat as a selection timeout.
5862 */
5863 if (sts == RQCS_PORT_UNAVAILABLE) {
5864 reason = "unavailable";
5865 } else {
5866 reason = "logout";
5867 }
5868
5869 isp_prt(isp, ISP_LOGINFO, "port %s for target %d",
5870 reason, XS_TGT(xs));
5871
5872 /*
5873 * If we're on a local loop, force a LIP (which is overkill)
5874 * to force a re-login of this unit. If we're on fabric,
5875 * then we'll have to log in again as a matter of course.
5876 */
5877 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
5878 FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
5879 mbreg_t mbs;
5880 MEMZERO(&mbs, sizeof (mbs));
5881 mbs.param[0] = MBOX_INIT_LIP;
5882 if (FCPARAM(isp)->isp_2klogin) {
5883 mbs.ibits = (1 << 10);
5884 }
5885 mbs.logval = MBLOGALL;
5886 isp_mboxcmd_qnw(isp, &mbs, 1);
5887 }
5888 if (XS_NOERR(xs)) {
5889 XS_SETERR(xs, HBA_SELTIMEOUT);
5890 }
5891 return;
5892 }
5893 case RQCS_PORT_CHANGED:
5894 isp_prt(isp, ISP_LOGWARN,
5895 "port changed for target %d", XS_TGT(xs));
5896 if (XS_NOERR(xs)) {
5897 XS_SETERR(xs, HBA_SELTIMEOUT);
5898 }
5899 return;
5900
5901 case RQCS_PORT_BUSY:
5902 isp_prt(isp, ISP_LOGWARN,
5903 "port busy for target %d", XS_TGT(xs));
5904 if (XS_NOERR(xs)) {
5905 XS_SETERR(xs, HBA_TGTBSY);
5906 }
5907 return;
5908
5909 default:
5910 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
5911 sp->req_completion_status);
5912 break;
5913 }
5914 if (XS_NOERR(xs)) {
5915 XS_SETERR(xs, HBA_BOTCH);
5916 }
5917}
5918
5919static void
5920isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp,
5921 XS_T *xs, long *rp)
5922{
5923 switch (sp->req_completion_status) {
5924 case RQCS_COMPLETE:
5925 if (XS_NOERR(xs)) {
5926 XS_SETERR(xs, HBA_NOERROR);
5927 }
5928 return;
5929
5930 case RQCS_DMA_ERROR:
5931 isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
5932 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5933 break;
5934
5935 case RQCS_TRANSPORT_ERROR:
5936 isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d",
5937 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5938 break;
5939
5940 case RQCS_RESET_OCCURRED:
5941 isp_prt(isp, ISP_LOGWARN,
5942 "bus reset destroyed command for %d.%d.%d",
5943 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5944 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
5945 if (XS_NOERR(xs)) {
5946 XS_SETERR(xs, HBA_BUSRESET);
5947 }
5948 return;
5949
5950 case RQCS_ABORTED:
5951 isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d",
5952 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5953 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
5954 if (XS_NOERR(xs)) {
5955 XS_SETERR(xs, HBA_ABORTED);
5956 }
5957 return;
5958
5959 case RQCS_TIMEOUT:
5960 isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
5961 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5962 if (XS_NOERR(xs)) {
5963 XS_SETERR(xs, HBA_CMDTIMEOUT);
5964 }
5965 return;
5966
5967 case RQCS_DATA_OVERRUN:
5968 XS_RESID(xs) = sp->req_resid;
5969 isp_prt(isp, ISP_LOGERR, "data overrun for command on %d.%d.%d",
5970 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5971 if (XS_NOERR(xs)) {
5972 XS_SETERR(xs, HBA_DATAOVR);
5973 }
5974 return;
5975
5976 case RQCS_24XX_DRE: /* data reassembly error */
5977 isp_prt(isp, ISP_LOGERR, "data reassembly error for target %d",
5978 XS_TGT(xs));
5979 if (XS_NOERR(xs)) {
5980 XS_SETERR(xs, HBA_ABORTED);
5981 }
5982 *rp = XS_XFRLEN(xs);
5983 return;
5984
5985 case RQCS_24XX_TABORT: /* aborted by target */
5986 isp_prt(isp, ISP_LOGERR, "target %d sent ABTS",
5987 XS_TGT(xs));
5988 if (XS_NOERR(xs)) {
5989 XS_SETERR(xs, HBA_ABORTED);
5990 }
5991 return;
5992
5993 case RQCS_DATA_UNDERRUN:
5994
5995 XS_RESID(xs) = sp->req_resid;
5996 if (XS_NOERR(xs)) {
5997 XS_SETERR(xs, HBA_NOERROR);
5998 }
5999 return;
6000
6001 case RQCS_PORT_UNAVAILABLE:
6002 /*
6003 * No such port on the loop. Moral equivalent of SELTIMEO
6004 */
6005 case RQCS_PORT_LOGGED_OUT:
6006 {
6007 char *reason;
6008 uint8_t sts = sp->req_completion_status & 0xff;
6009
6010 /*
6011 * It was there (maybe)- treat as a selection timeout.
6012 */
6013 if (sts == RQCS_PORT_UNAVAILABLE) {
6014 reason = "unavailable";
6015 } else {
6016 reason = "logout";
6017 }
6018
6019 isp_prt(isp, ISP_LOGINFO, "port %s for target %d",
6020 reason, XS_TGT(xs));
6021
6022 /*
6023 * If we're on a local loop, force a LIP (which is overkill)
6024 * to force a re-login of this unit. If we're on fabric,
6025 * then we'll have to log in again as a matter of course.
6026 */
6027 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
6028 FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
6029 mbreg_t mbs;
6030 MEMZERO(&mbs, sizeof (mbs));
6031 mbs.param[0] = MBOX_INIT_LIP;
6032 if (FCPARAM(isp)->isp_2klogin) {
6033 mbs.ibits = (1 << 10);
6034 }
6035 mbs.logval = MBLOGALL;
6036 isp_mboxcmd_qnw(isp, &mbs, 1);
6037 }
6038 if (XS_NOERR(xs)) {
6039 XS_SETERR(xs, HBA_SELTIMEOUT);
6040 }
6041 return;
6042 }
6043 case RQCS_PORT_CHANGED:
6044 isp_prt(isp, ISP_LOGWARN,
6045 "port changed for target %d", XS_TGT(xs));
6046 if (XS_NOERR(xs)) {
6047 XS_SETERR(xs, HBA_SELTIMEOUT);
6048 }
6049 return;
6050
6051
6052 case RQCS_24XX_ENOMEM: /* f/w resource unavailable */
6053 isp_prt(isp, ISP_LOGWARN,
6054 "f/w resource unavailable for target %d", XS_TGT(xs));
6055 if (XS_NOERR(xs)) {
6056 *XS_STSP(xs) = SCSI_BUSY;
6057 XS_SETERR(xs, HBA_TGTBSY);
6058 }
6059 return;
6060
6061 case RQCS_24XX_TMO: /* task management overrun */
6062 isp_prt(isp, ISP_LOGWARN,
6063 "command for target %d overlapped task management",
6064 XS_TGT(xs));
6065 if (XS_NOERR(xs)) {
6066 *XS_STSP(xs) = SCSI_BUSY;
6067 XS_SETERR(xs, HBA_TGTBSY);
6068 }
6069 return;
6070
6071 default:
6072 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
6073 sp->req_completion_status);
6074 break;
6075 }
6076 if (XS_NOERR(xs)) {
6077 XS_SETERR(xs, HBA_BOTCH);
6078 }
6079}
6080
6081static void
6082isp_fastpost_complete(ispsoftc_t *isp, uint16_t fph)
6083{
6084 XS_T *xs;
6085
6086 if (fph == 0) {
6087 return;
6088 }
6089 xs = isp_find_xs(isp, fph);
6090 if (xs == NULL) {
6091 isp_prt(isp, ISP_LOGWARN,
6092 "Command for fast post handle 0x%x not found", fph);
6093 return;
6094 }
6095 isp_destroy_handle(isp, fph);
6096
6097 /*
6098 * Since we don't have a result queue entry item,
6099 * we must believe that SCSI status is zero and
6100 * that all data transferred.
6101 */
6102 XS_SET_STATE_STAT(isp, xs, NULL);
6103 XS_RESID(xs) = 0;
6104 *XS_STSP(xs) = SCSI_GOOD;
6105 if (XS_XFRLEN(xs)) {
6106 ISP_DMAFREE(isp, xs, fph);
6107 }
6108 if (isp->isp_nactive)
6109 isp->isp_nactive--;
6110 isp->isp_fphccmplt++;
6111 isp_done(xs);
6112}
6113
6114static int
6115isp_mbox_continue(ispsoftc_t *isp)
6116{
6117 mbreg_t mbs;
6118 uint16_t *ptr;
6119 uint32_t offset;
6120
6121 switch (isp->isp_lastmbxcmd) {
6122 case MBOX_WRITE_RAM_WORD:
6123 case MBOX_READ_RAM_WORD:
6124 case MBOX_WRITE_RAM_WORD_EXTENDED:
6125 case MBOX_READ_RAM_WORD_EXTENDED:
6126 break;
6127 default:
6128 return (1);
6129 }
6130 if (isp->isp_mboxtmp[0] != MBOX_COMMAND_COMPLETE) {
6131 isp->isp_mbxwrk0 = 0;
6132 return (-1);
6133 }
6134
6135 /*
6136 * Clear the previous interrupt.
6137 */
6138 if (IS_24XX(isp)) {
6139 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
6140 } else {
6141 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
6142 ISP_WRITE(isp, BIU_SEMA, 0);
6143 }
6144
6145 /*
6146 * Continue with next word.
6147 */
6148 MEMZERO(&mbs, sizeof (mbs));
6149 ptr = isp->isp_mbxworkp;
6150 switch (isp->isp_lastmbxcmd) {
6151 case MBOX_WRITE_RAM_WORD:
6152 mbs.param[1] = isp->isp_mbxwrk1++;;
6153 mbs.param[2] = *ptr++;;
6154 break;
6155 case MBOX_READ_RAM_WORD:
6156 *ptr++ = isp->isp_mboxtmp[2];
6157 mbs.param[1] = isp->isp_mbxwrk1++;
6158 break;
6159 case MBOX_WRITE_RAM_WORD_EXTENDED:
6160 offset = isp->isp_mbxwrk1;
6161 offset |= isp->isp_mbxwrk8 << 16;
6162
6163 mbs.param[2] = *ptr++;;
6164 mbs.param[1] = offset;
6165 mbs.param[8] = offset >> 16;
6166 isp->isp_mbxwrk1 = ++offset;
6167 isp->isp_mbxwrk8 = offset >> 16;
6168 break;
6169 case MBOX_READ_RAM_WORD_EXTENDED:
6170 offset = isp->isp_mbxwrk1;
6171 offset |= isp->isp_mbxwrk8 << 16;
6172
6173 *ptr++ = isp->isp_mboxtmp[2];
6174 mbs.param[1] = offset;
6175 mbs.param[8] = offset >> 16;
6176 isp->isp_mbxwrk1 = ++offset;
6177 isp->isp_mbxwrk8 = offset >> 16;
6178 break;
6179 }
6180 isp->isp_mbxworkp = ptr;
6181 isp->isp_mbxwrk0--;
6182 mbs.param[0] = isp->isp_lastmbxcmd;
6183 mbs.logval = MBLOGALL;
6184 isp_mboxcmd_qnw(isp, &mbs, 0);
6185 return (0);
6186}
6187
6188#define HIWRD(x) ((x) >> 16)
6189#define LOWRD(x) ((x) & 0xffff)
6190#define ISPOPMAP(a, b) (((a) << 16) | (b))
6191static const uint32_t mbpscsi[] = {
6192 ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
6193 ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
6194 ISPOPMAP(0x03, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */
6195 ISPOPMAP(0x1f, 0x01), /* 0x03: MBOX_DUMP_RAM */
6196 ISPOPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
6197 ISPOPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
6198 ISPOPMAP(0x3f, 0x3f), /* 0x06: MBOX_MAILBOX_REG_TEST */
6199 ISPOPMAP(0x07, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */
6200 ISPOPMAP(0x01, 0x0f), /* 0x08: MBOX_ABOUT_FIRMWARE */
6201 ISPOPMAP(0x00, 0x00), /* 0x09: */
6202 ISPOPMAP(0x00, 0x00), /* 0x0a: */
6203 ISPOPMAP(0x00, 0x00), /* 0x0b: */
6204 ISPOPMAP(0x00, 0x00), /* 0x0c: */
6205 ISPOPMAP(0x00, 0x00), /* 0x0d: */
6206 ISPOPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
6207 ISPOPMAP(0x00, 0x00), /* 0x0f: */
6208 ISPOPMAP(0x1f, 0x1f), /* 0x10: MBOX_INIT_REQ_QUEUE */
6209 ISPOPMAP(0x3f, 0x3f), /* 0x11: MBOX_INIT_RES_QUEUE */
6210 ISPOPMAP(0x0f, 0x0f), /* 0x12: MBOX_EXECUTE_IOCB */
6211 ISPOPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */
6212 ISPOPMAP(0x01, 0x3f), /* 0x14: MBOX_STOP_FIRMWARE */
6213 ISPOPMAP(0x0f, 0x0f), /* 0x15: MBOX_ABORT */
6214 ISPOPMAP(0x03, 0x03), /* 0x16: MBOX_ABORT_DEVICE */
6215 ISPOPMAP(0x07, 0x07), /* 0x17: MBOX_ABORT_TARGET */
6216 ISPOPMAP(0x07, 0x07), /* 0x18: MBOX_BUS_RESET */
6217 ISPOPMAP(0x03, 0x07), /* 0x19: MBOX_STOP_QUEUE */
6218 ISPOPMAP(0x03, 0x07), /* 0x1a: MBOX_START_QUEUE */
6219 ISPOPMAP(0x03, 0x07), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6220 ISPOPMAP(0x03, 0x07), /* 0x1c: MBOX_ABORT_QUEUE */
6221 ISPOPMAP(0x03, 0x4f), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6222 ISPOPMAP(0x00, 0x00), /* 0x1e: */
6223 ISPOPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6224 ISPOPMAP(0x01, 0x07), /* 0x20: MBOX_GET_INIT_SCSI_ID */
6225 ISPOPMAP(0x01, 0x07), /* 0x21: MBOX_GET_SELECT_TIMEOUT */
6226 ISPOPMAP(0x01, 0xc7), /* 0x22: MBOX_GET_RETRY_COUNT */
6227 ISPOPMAP(0x01, 0x07), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
6228 ISPOPMAP(0x01, 0x03), /* 0x24: MBOX_GET_CLOCK_RATE */
6229 ISPOPMAP(0x01, 0x07), /* 0x25: MBOX_GET_ACT_NEG_STATE */
6230 ISPOPMAP(0x01, 0x07), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
6231 ISPOPMAP(0x01, 0x07), /* 0x27: MBOX_GET_PCI_PARAMS */
6232 ISPOPMAP(0x03, 0x4f), /* 0x28: MBOX_GET_TARGET_PARAMS */
6233 ISPOPMAP(0x03, 0x0f), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
6234 ISPOPMAP(0x01, 0x07), /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */
6235 ISPOPMAP(0x00, 0x00), /* 0x2b: */
6236 ISPOPMAP(0x00, 0x00), /* 0x2c: */
6237 ISPOPMAP(0x00, 0x00), /* 0x2d: */
6238 ISPOPMAP(0x00, 0x00), /* 0x2e: */
6239 ISPOPMAP(0x00, 0x00), /* 0x2f: */
6240 ISPOPMAP(0x03, 0x03), /* 0x30: MBOX_SET_INIT_SCSI_ID */
6241 ISPOPMAP(0x07, 0x07), /* 0x31: MBOX_SET_SELECT_TIMEOUT */
6242 ISPOPMAP(0xc7, 0xc7), /* 0x32: MBOX_SET_RETRY_COUNT */
6243 ISPOPMAP(0x07, 0x07), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
6244 ISPOPMAP(0x03, 0x03), /* 0x34: MBOX_SET_CLOCK_RATE */
6245 ISPOPMAP(0x07, 0x07), /* 0x35: MBOX_SET_ACT_NEG_STATE */
6246 ISPOPMAP(0x07, 0x07), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
6247 ISPOPMAP(0x07, 0x07), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
6248 ISPOPMAP(0x4f, 0x4f), /* 0x38: MBOX_SET_TARGET_PARAMS */
6249 ISPOPMAP(0x0f, 0x0f), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
6250 ISPOPMAP(0x07, 0x07), /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */
6251 ISPOPMAP(0x00, 0x00), /* 0x3b: */
6252 ISPOPMAP(0x00, 0x00), /* 0x3c: */
6253 ISPOPMAP(0x00, 0x00), /* 0x3d: */
6254 ISPOPMAP(0x00, 0x00), /* 0x3e: */
6255 ISPOPMAP(0x00, 0x00), /* 0x3f: */
6256 ISPOPMAP(0x01, 0x03), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
6257 ISPOPMAP(0x3f, 0x01), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
6258 ISPOPMAP(0x03, 0x07), /* 0x42: MBOX_EXEC_BIOS_IOCB */
6259 ISPOPMAP(0x00, 0x00), /* 0x43: */
6260 ISPOPMAP(0x00, 0x00), /* 0x44: */
6261 ISPOPMAP(0x03, 0x03), /* 0x45: SET SYSTEM PARAMETER */
6262 ISPOPMAP(0x01, 0x03), /* 0x46: GET SYSTEM PARAMETER */
6263 ISPOPMAP(0x00, 0x00), /* 0x47: */
6264 ISPOPMAP(0x01, 0xcf), /* 0x48: GET SCAM CONFIGURATION */
6265 ISPOPMAP(0xcf, 0xcf), /* 0x49: SET SCAM CONFIGURATION */
6266 ISPOPMAP(0x03, 0x03), /* 0x4a: MBOX_SET_FIRMWARE_FEATURES */
6267 ISPOPMAP(0x01, 0x03), /* 0x4b: MBOX_GET_FIRMWARE_FEATURES */
6268 ISPOPMAP(0x00, 0x00), /* 0x4c: */
6269 ISPOPMAP(0x00, 0x00), /* 0x4d: */
6270 ISPOPMAP(0x00, 0x00), /* 0x4e: */
6271 ISPOPMAP(0x00, 0x00), /* 0x4f: */
6272 ISPOPMAP(0xdf, 0xdf), /* 0x50: LOAD RAM A64 */
6273 ISPOPMAP(0xdf, 0xdf), /* 0x51: DUMP RAM A64 */
6274 ISPOPMAP(0xdf, 0xff), /* 0x52: INITIALIZE REQUEST QUEUE A64 */
6275 ISPOPMAP(0xef, 0xff), /* 0x53: INITIALIZE RESPONSE QUEUE A64 */
6276 ISPOPMAP(0xcf, 0x01), /* 0x54: EXECUCUTE COMMAND IOCB A64 */
6277 ISPOPMAP(0x07, 0x01), /* 0x55: ENABLE TARGET MODE */
6278 ISPOPMAP(0x03, 0x0f), /* 0x56: GET TARGET STATUS */
6279 ISPOPMAP(0x00, 0x00), /* 0x57: */
6280 ISPOPMAP(0x00, 0x00), /* 0x58: */
6281 ISPOPMAP(0x00, 0x00), /* 0x59: */
6282 ISPOPMAP(0x03, 0x03), /* 0x5a: SET DATA OVERRUN RECOVERY MODE */
6283 ISPOPMAP(0x01, 0x03), /* 0x5b: GET DATA OVERRUN RECOVERY MODE */
6284 ISPOPMAP(0x0f, 0x0f), /* 0x5c: SET HOST DATA */
6285 ISPOPMAP(0x01, 0x01) /* 0x5d: GET NOST DATA */
6286};
6287
6288static char *scsi_mbcmd_names[] = {
6289 "NO-OP",
6290 "LOAD RAM",
6291 "EXEC FIRMWARE",
6292 "DUMP RAM",
6293 "WRITE RAM WORD",
6294 "READ RAM WORD",
6295 "MAILBOX REG TEST",
6296 "VERIFY CHECKSUM",
6297 "ABOUT FIRMWARE",
6298 NULL,
6299 NULL,
6300 NULL,
6301 NULL,
6302 NULL,
6303 "CHECK FIRMWARE",
6304 NULL,
6305 "INIT REQUEST QUEUE",
6306 "INIT RESULT QUEUE",
6307 "EXECUTE IOCB",
6308 "WAKE UP",
6309 "STOP FIRMWARE",
6310 "ABORT",
6311 "ABORT DEVICE",
6312 "ABORT TARGET",
6313 "BUS RESET",
6314 "STOP QUEUE",
6315 "START QUEUE",
6316 "SINGLE STEP QUEUE",
6317 "ABORT QUEUE",
6318 "GET DEV QUEUE STATUS",
6319 NULL,
6320 "GET FIRMWARE STATUS",
6321 "GET INIT SCSI ID",
6322 "GET SELECT TIMEOUT",
6323 "GET RETRY COUNT",
6324 "GET TAG AGE LIMIT",
6325 "GET CLOCK RATE",
6326 "GET ACT NEG STATE",
6327 "GET ASYNC DATA SETUP TIME",
6328 "GET PCI PARAMS",
6329 "GET TARGET PARAMS",
6330 "GET DEV QUEUE PARAMS",
6331 "GET RESET DELAY PARAMS",
6332 NULL,
6333 NULL,
6334 NULL,
6335 NULL,
6336 NULL,
6337 "SET INIT SCSI ID",
6338 "SET SELECT TIMEOUT",
6339 "SET RETRY COUNT",
6340 "SET TAG AGE LIMIT",
6341 "SET CLOCK RATE",
6342 "SET ACT NEG STATE",
6343 "SET ASYNC DATA SETUP TIME",
6344 "SET PCI CONTROL PARAMS",
6345 "SET TARGET PARAMS",
6346 "SET DEV QUEUE PARAMS",
6347 "SET RESET DELAY PARAMS",
6348 NULL,
6349 NULL,
6350 NULL,
6351 NULL,
6352 NULL,
6353 "RETURN BIOS BLOCK ADDR",
6354 "WRITE FOUR RAM WORDS",
6355 "EXEC BIOS IOCB",
6356 NULL,
6357 NULL,
6358 "SET SYSTEM PARAMETER",
6359 "GET SYSTEM PARAMETER",
6360 NULL,
6361 "GET SCAM CONFIGURATION",
6362 "SET SCAM CONFIGURATION",
6363 "SET FIRMWARE FEATURES",
6364 "GET FIRMWARE FEATURES",
6365 NULL,
6366 NULL,
6367 NULL,
6368 NULL,
6369 "LOAD RAM A64",
6370 "DUMP RAM A64",
6371 "INITIALIZE REQUEST QUEUE A64",
6372 "INITIALIZE RESPONSE QUEUE A64",
6373 "EXECUTE IOCB A64",
6374 "ENABLE TARGET MODE",
6375 "GET TARGET MODE STATE",
6376 NULL,
6377 NULL,
6378 NULL,
6379 "SET DATA OVERRUN RECOVERY MODE",
6380 "GET DATA OVERRUN RECOVERY MODE",
6381 "SET HOST DATA",
6382 "GET NOST DATA",
6383};
6384
6385static const uint32_t mbpfc[] = {
6386 ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
6387 ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
6388 ISPOPMAP(0x0f, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */
6389 ISPOPMAP(0xdf, 0x01), /* 0x03: MBOX_DUMP_RAM */
6390 ISPOPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
6391 ISPOPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
6392 ISPOPMAP(0xff, 0xff), /* 0x06: MBOX_MAILBOX_REG_TEST */
6393 ISPOPMAP(0x03, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */
6394 ISPOPMAP(0x01, 0x4f), /* 0x08: MBOX_ABOUT_FIRMWARE */
6395 ISPOPMAP(0xdf, 0x01), /* 0x09: MBOX_LOAD_RISC_RAM_2100 */
6396 ISPOPMAP(0xdf, 0x01), /* 0x0a: DUMP RAM */
6397 ISPOPMAP(0x1ff, 0x01), /* 0x0b: MBOX_LOAD_RISC_RAM */
6398 ISPOPMAP(0x00, 0x00), /* 0x0c: */
6399 ISPOPMAP(0x10f, 0x01), /* 0x0d: MBOX_WRITE_RAM_WORD_EXTENDED */
6400 ISPOPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
6401 ISPOPMAP(0x10f, 0x05), /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED */
6402 ISPOPMAP(0x1f, 0x11), /* 0x10: MBOX_INIT_REQ_QUEUE */
6403 ISPOPMAP(0x2f, 0x21), /* 0x11: MBOX_INIT_RES_QUEUE */
6404 ISPOPMAP(0x0f, 0x01), /* 0x12: MBOX_EXECUTE_IOCB */
6405 ISPOPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */
6406 ISPOPMAP(0x01, 0xff), /* 0x14: MBOX_STOP_FIRMWARE */
6407 ISPOPMAP(0x4f, 0x01), /* 0x15: MBOX_ABORT */
6408 ISPOPMAP(0x07, 0x01), /* 0x16: MBOX_ABORT_DEVICE */
6409 ISPOPMAP(0x07, 0x01), /* 0x17: MBOX_ABORT_TARGET */
6410 ISPOPMAP(0x03, 0x03), /* 0x18: MBOX_BUS_RESET */
6411 ISPOPMAP(0x07, 0x05), /* 0x19: MBOX_STOP_QUEUE */
6412 ISPOPMAP(0x07, 0x05), /* 0x1a: MBOX_START_QUEUE */
6413 ISPOPMAP(0x07, 0x05), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6414 ISPOPMAP(0x07, 0x05), /* 0x1c: MBOX_ABORT_QUEUE */
6415 ISPOPMAP(0x07, 0x03), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6416 ISPOPMAP(0x00, 0x00), /* 0x1e: */
6417 ISPOPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6418 ISPOPMAP(0x01, 0x4f), /* 0x20: MBOX_GET_LOOP_ID */
6419 ISPOPMAP(0x00, 0x00), /* 0x21: */
6420 ISPOPMAP(0x01, 0x07), /* 0x22: MBOX_GET_RETRY_COUNT */
6421 ISPOPMAP(0x00, 0x00), /* 0x23: */
6422 ISPOPMAP(0x00, 0x00), /* 0x24: */
6423 ISPOPMAP(0x00, 0x00), /* 0x25: */
6424 ISPOPMAP(0x00, 0x00), /* 0x26: */
6425 ISPOPMAP(0x00, 0x00), /* 0x27: */
6426 ISPOPMAP(0x01, 0x03), /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */
6427 ISPOPMAP(0x03, 0x07), /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */
6428 ISPOPMAP(0x00, 0x00), /* 0x2a: */
6429 ISPOPMAP(0x00, 0x00), /* 0x2b: */
6430 ISPOPMAP(0x00, 0x00), /* 0x2c: */
6431 ISPOPMAP(0x00, 0x00), /* 0x2d: */
6432 ISPOPMAP(0x00, 0x00), /* 0x2e: */
6433 ISPOPMAP(0x00, 0x00), /* 0x2f: */
6434 ISPOPMAP(0x00, 0x00), /* 0x30: */
6435 ISPOPMAP(0x00, 0x00), /* 0x31: */
6436 ISPOPMAP(0x07, 0x07), /* 0x32: MBOX_SET_RETRY_COUNT */
6437 ISPOPMAP(0x00, 0x00), /* 0x33: */
6438 ISPOPMAP(0x00, 0x00), /* 0x34: */
6439 ISPOPMAP(0x00, 0x00), /* 0x35: */
6440 ISPOPMAP(0x00, 0x00), /* 0x36: */
6441 ISPOPMAP(0x00, 0x00), /* 0x37: */
6442 ISPOPMAP(0x0f, 0x01), /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */
6443 ISPOPMAP(0x0f, 0x07), /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */
6444 ISPOPMAP(0x00, 0x00), /* 0x3a: */
6445 ISPOPMAP(0x00, 0x00), /* 0x3b: */
6446 ISPOPMAP(0x00, 0x00), /* 0x3c: */
6447 ISPOPMAP(0x00, 0x00), /* 0x3d: */
6448 ISPOPMAP(0x00, 0x00), /* 0x3e: */
6449 ISPOPMAP(0x00, 0x00), /* 0x3f: */
6450 ISPOPMAP(0x03, 0x01), /* 0x40: MBOX_LOOP_PORT_BYPASS */
6451 ISPOPMAP(0x03, 0x01), /* 0x41: MBOX_LOOP_PORT_ENABLE */
6452 ISPOPMAP(0x03, 0x07), /* 0x42: MBOX_GET_RESOURCE_COUNT */
6453 ISPOPMAP(0x01, 0x01), /* 0x43: MBOX_REQUEST_OFFLINE_MODE */
6454 ISPOPMAP(0x00, 0x00), /* 0x44: */
6455 ISPOPMAP(0x00, 0x00), /* 0x45: */
6456 ISPOPMAP(0x00, 0x00), /* 0x46: */
6457 ISPOPMAP(0xcf, 0x03), /* 0x47: GET PORT_DATABASE ENHANCED */
6458 ISPOPMAP(0x00, 0x00), /* 0x48: */
6459 ISPOPMAP(0x00, 0x00), /* 0x49: */
6460 ISPOPMAP(0x00, 0x00), /* 0x4a: */
6461 ISPOPMAP(0x00, 0x00), /* 0x4b: */
6462 ISPOPMAP(0x00, 0x00), /* 0x4c: */
6463 ISPOPMAP(0x00, 0x00), /* 0x4d: */
6464 ISPOPMAP(0x00, 0x00), /* 0x4e: */
6465 ISPOPMAP(0x00, 0x00), /* 0x4f: */
6466 ISPOPMAP(0x00, 0x00), /* 0x50: */
6467 ISPOPMAP(0x00, 0x00), /* 0x51: */
6468 ISPOPMAP(0x00, 0x00), /* 0x52: */
6469 ISPOPMAP(0x00, 0x00), /* 0x53: */
6470 ISPOPMAP(0xcf, 0x01), /* 0x54: EXECUTE IOCB A64 */
6471 ISPOPMAP(0x00, 0x00), /* 0x55: */
6472 ISPOPMAP(0x00, 0x00), /* 0x56: */
6473 ISPOPMAP(0x00, 0x00), /* 0x57: */
6474 ISPOPMAP(0x00, 0x00), /* 0x58: */
6475 ISPOPMAP(0x00, 0x00), /* 0x59: */
6476 ISPOPMAP(0x00, 0x00), /* 0x5a: */
6477 ISPOPMAP(0x03, 0x01), /* 0x5b: MBOX_DRIVER_HEARTBEAT */
6478 ISPOPMAP(0xcf, 0x01), /* 0x5c: MBOX_FW_HEARTBEAT */
6479 ISPOPMAP(0x07, 0x03), /* 0x5d: MBOX_GET_SET_DATA_RATE */
6480 ISPOPMAP(0x00, 0x00), /* 0x5e: */
6481 ISPOPMAP(0x00, 0x00), /* 0x5f: */
6482 ISPOPMAP(0xcd, 0x01), /* 0x60: MBOX_INIT_FIRMWARE */
6483 ISPOPMAP(0x00, 0x00), /* 0x61: */
6484 ISPOPMAP(0x01, 0x01), /* 0x62: MBOX_INIT_LIP */
6485 ISPOPMAP(0xcd, 0x03), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
6486 ISPOPMAP(0xcf, 0x01), /* 0x64: MBOX_GET_PORT_DB */
6487 ISPOPMAP(0x07, 0x01), /* 0x65: MBOX_CLEAR_ACA */
6488 ISPOPMAP(0x07, 0x01), /* 0x66: MBOX_TARGET_RESET */
6489 ISPOPMAP(0x07, 0x01), /* 0x67: MBOX_CLEAR_TASK_SET */
6490 ISPOPMAP(0x07, 0x01), /* 0x68: MBOX_ABORT_TASK_SET */
6491 ISPOPMAP(0x01, 0x07), /* 0x69: MBOX_GET_FW_STATE */
6492 ISPOPMAP(0x03, 0xcf), /* 0x6a: MBOX_GET_PORT_NAME */
6493 ISPOPMAP(0xcf, 0x01), /* 0x6b: MBOX_GET_LINK_STATUS */
6494 ISPOPMAP(0x0f, 0x01), /* 0x6c: MBOX_INIT_LIP_RESET */
6495 ISPOPMAP(0x00, 0x00), /* 0x6d: */
6496 ISPOPMAP(0xcf, 0x03), /* 0x6e: MBOX_SEND_SNS */
6497 ISPOPMAP(0x0f, 0x07), /* 0x6f: MBOX_FABRIC_LOGIN */
6498 ISPOPMAP(0x03, 0x01), /* 0x70: MBOX_SEND_CHANGE_REQUEST */
6499 ISPOPMAP(0x03, 0x03), /* 0x71: MBOX_FABRIC_LOGOUT */
6500 ISPOPMAP(0x0f, 0x0f), /* 0x72: MBOX_INIT_LIP_LOGIN */
6501 ISPOPMAP(0x00, 0x00), /* 0x73: */
6502 ISPOPMAP(0x07, 0x01), /* 0x74: LOGIN LOOP PORT */
6503 ISPOPMAP(0xcf, 0x03), /* 0x75: GET PORT/NODE NAME LIST */
6504 ISPOPMAP(0x4f, 0x01), /* 0x76: SET VENDOR ID */
6505 ISPOPMAP(0xcd, 0x01), /* 0x77: INITIALIZE IP MAILBOX */
6506 ISPOPMAP(0x00, 0x00), /* 0x78: */
6507 ISPOPMAP(0x00, 0x00), /* 0x79: */
6508 ISPOPMAP(0x00, 0x00), /* 0x7a: */
6509 ISPOPMAP(0x00, 0x00), /* 0x7b: */
6510 ISPOPMAP(0x4f, 0x03), /* 0x7c: Get ID List */
6511 ISPOPMAP(0xcf, 0x01), /* 0x7d: SEND LFA */
6512 ISPOPMAP(0x0f, 0x01) /* 0x7e: LUN RESET */
6513};
6514/*
6515 * Footnotes
6516 *
6517 * (1): this sets bits 21..16 in mailbox register #8, which we nominally
6518 * do not access at this time in the core driver. The caller is
6519 * responsible for setting this register first (Gross!). The assumption
6520 * is that we won't overflow.
6521 */
6522
6523static char *fc_mbcmd_names[] = {
6524 "NO-OP",
6525 "LOAD RAM",
6526 "EXEC FIRMWARE",
6527 "DUMP RAM",
6528 "WRITE RAM WORD",
6529 "READ RAM WORD",
6530 "MAILBOX REG TEST",
6531 "VERIFY CHECKSUM",
6532 "ABOUT FIRMWARE",
6533 "LOAD RAM",
6534 "DUMP RAM",
6535 "WRITE RAM WORD EXTENDED",
6536 NULL,
6537 "READ RAM WORD EXTENDED",
6538 "CHECK FIRMWARE",
6539 NULL,
6540 "INIT REQUEST QUEUE",
6541 "INIT RESULT QUEUE",
6542 "EXECUTE IOCB",
6543 "WAKE UP",
6544 "STOP FIRMWARE",
6545 "ABORT",
6546 "ABORT DEVICE",
6547 "ABORT TARGET",
6548 "BUS RESET",
6549 "STOP QUEUE",
6550 "START QUEUE",
6551 "SINGLE STEP QUEUE",
6552 "ABORT QUEUE",
6553 "GET DEV QUEUE STATUS",
6554 NULL,
6555 "GET FIRMWARE STATUS",
6556 "GET LOOP ID",
6557 NULL,
6558 "GET RETRY COUNT",
6559 NULL,
6560 NULL,
6561 NULL,
6562 NULL,
6563 NULL,
6564 "GET FIRMWARE OPTIONS",
6565 "GET PORT QUEUE PARAMS",
6566 NULL,
6567 NULL,
6568 NULL,
6569 NULL,
6570 NULL,
6571 NULL,
6572 NULL,
6573 NULL,
6574 "SET RETRY COUNT",
6575 NULL,
6576 NULL,
6577 NULL,
6578 NULL,
6579 NULL,
6580 "SET FIRMWARE OPTIONS",
6581 "SET PORT QUEUE PARAMS",
6582 NULL,
6583 NULL,
6584 NULL,
6585 NULL,
6586 NULL,
6587 NULL,
6588 "LOOP PORT BYPASS",
6589 "LOOP PORT ENABLE",
6590 "GET RESOURCE COUNT",
6591 "REQUEST NON PARTICIPATING MODE",
6592 NULL,
6593 NULL,
6594 NULL,
6595 "GET PORT DATABASE ENHANCED",
6596 NULL,
6597 NULL,
6598 NULL,
6599 NULL,
6600 NULL,
6601 NULL,
6602 NULL,
6603 NULL,
6604 NULL,
6605 NULL,
6606 NULL,
6607 NULL,
6608 "EXECUTE IOCB A64",
6609 NULL,
6610 NULL,
6611 NULL,
6612 NULL,
6613 NULL,
6614 NULL,
6615 "DRIVER HEARTBEAT",
6616 NULL,
6617 "GET/SET DATA RATE",
6618 NULL,
6619 NULL,
6620 "INIT FIRMWARE",
6621 NULL,
6622 "INIT LIP",
6623 "GET FC-AL POSITION MAP",
6624 "GET PORT DATABASE",
6625 "CLEAR ACA",
6626 "TARGET RESET",
6627 "CLEAR TASK SET",
6628 "ABORT TASK SET",
6629 "GET FW STATE",
6630 "GET PORT NAME",
6631 "GET LINK STATUS",
6632 "INIT LIP RESET",
6633 NULL,
6634 "SEND SNS",
6635 "FABRIC LOGIN",
6636 "SEND CHANGE REQUEST",
6637 "FABRIC LOGOUT",
6638 "INIT LIP LOGIN",
6639 NULL,
6640 "LOGIN LOOP PORT",
6641 "GET PORT/NODE NAME LIST",
6642 "SET VENDOR ID",
6643 "INITIALIZE IP MAILBOX",
6644 NULL,
6645 NULL,
6646 NULL,
6647 NULL,
6648 "Get ID List",
6649 "SEND LFA",
6650 "Lun RESET"
6651};
6652
6653static void
6654isp_mboxcmd_qnw(ispsoftc_t *isp, mbreg_t *mbp, int nodelay)
6655{
6656 unsigned int ibits, obits, box, opcode;
6657 const uint32_t *mcp;
6658
6659 if (IS_FC(isp)) {
6660 mcp = mbpfc;
6661 } else {
6662 mcp = mbpscsi;
6663 }
6664 opcode = mbp->param[0];
6665 ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp);
6666 obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp);
6667 ibits |= mbp->ibits;
6668 obits |= mbp->obits;
6669 for (box = 0; box < MAX_MAILBOX(isp); box++) {
6670 if (ibits & (1 << box)) {
6671 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
6672 }
6673 if (nodelay == 0) {
6674 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
6675 }
6676 }
6677 if (nodelay == 0) {
6678 isp->isp_lastmbxcmd = opcode;
6679 isp->isp_obits = obits;
6680 isp->isp_mboxbsy = 1;
6681 }
6682 if (IS_24XX(isp)) {
6683 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
6684 } else {
6685 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
6686 }
6687 /*
6688 * Oddly enough, if we're not delaying for an answer,
6689 * delay a bit to give the f/w a chance to pick up the
6690 * command.
6691 */
6692 if (nodelay) {
6693 USEC_DELAY(1000);
6694 }
6695}
6696
6697static void
6698isp_mboxcmd(ispsoftc_t *isp, mbreg_t *mbp)
6699{
6700 char *cname, *xname, tname[16], mname[16];
6701 unsigned int lim, ibits, obits, box, opcode;
6702 const uint32_t *mcp;
6703
6704 if (IS_FC(isp)) {
6705 mcp = mbpfc;
6706 lim = (sizeof (mbpfc) / sizeof (mbpfc[0]));
6707 } else {
6708 mcp = mbpscsi;
6709 lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0]));
6710 }
6711
6712 if ((opcode = mbp->param[0]) >= lim) {
6713 mbp->param[0] = MBOX_INVALID_COMMAND;
6714 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
6715 return;
6716 }
6717
6718 ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp);
6719 obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp);
6720
6721 /*
6722 * Pick up any additional bits that the caller might have set.
6723 */
6724 ibits |= mbp->ibits;
6725 obits |= mbp->obits;
6726
6727 if (ibits == 0 && obits == 0) {
6728 mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
6729 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
6730 return;
6731 }
6732
6733 /*
6734 * Get exclusive usage of mailbox registers.
6735 */
6736 if (MBOX_ACQUIRE(isp)) {
6737 mbp->param[0] = MBOX_REGS_BUSY;
6738 goto out;
6739 }
6740
6741 for (box = 0; box < MAX_MAILBOX(isp); box++) {
6742 if (ibits & (1 << box)) {
6743 isp_prt(isp, ISP_LOGDEBUG1, "IN mbox %d = 0x%04x", box,
6744 mbp->param[box]);
6745 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
6746 }
6747 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
6748 }
6749
6750 isp->isp_lastmbxcmd = opcode;
6751
6752 /*
6753 * We assume that we can't overwrite a previous command.
6754 */
6755 isp->isp_obits = obits;
6756 isp->isp_mboxbsy = 1;
6757
6758 /*
6759 * Set Host Interrupt condition so that RISC will pick up mailbox regs.
6760 */
6761 if (IS_24XX(isp)) {
6762 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
6763 } else {
6764 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
6765 }
6766
6767 /*
6768 * While we haven't finished the command, spin our wheels here.
6769 */
6770 MBOX_WAIT_COMPLETE(isp, mbp);
6771
6772 /*
6773 * Did the command time out?
6774 */
6775 if (mbp->param[0] == MBOX_TIMEOUT) {
6776 MBOX_RELEASE(isp);
6777 goto out;
6778 }
6779
6780 /*
6781 * Copy back output registers.
6782 */
6783 for (box = 0; box < MAX_MAILBOX(isp); box++) {
6784 if (obits & (1 << box)) {
6785 mbp->param[box] = isp->isp_mboxtmp[box];
6786 isp_prt(isp, ISP_LOGDEBUG1, "OUT mbox %d = 0x%04x", box,
6787 mbp->param[box]);
6788 }
6789 }
6790
6791 MBOX_RELEASE(isp);
6792 out:
6793 isp->isp_mboxbsy = 0;
6794 if (mbp->logval == 0 || opcode == MBOX_EXEC_FIRMWARE) {
6795 return;
6796 }
6797 cname = (IS_FC(isp))? fc_mbcmd_names[opcode] : scsi_mbcmd_names[opcode];
6798 if (cname == NULL) {
6799 cname = tname;
6800 SNPRINTF(tname, sizeof tname, "opcode %x", opcode);
6801 }
6802
6803 /*
6804 * Just to be chatty here...
6805 */
6806 xname = NULL;
6807 switch (mbp->param[0]) {
6808 case MBOX_COMMAND_COMPLETE:
6809 break;
6810 case MBOX_INVALID_COMMAND:
6811 if (mbp->logval & MBLOGMASK(MBOX_COMMAND_COMPLETE)) {
6812 xname = "INVALID COMMAND";
6813 }
6814 break;
6815 case MBOX_HOST_INTERFACE_ERROR:
6816 if (mbp->logval & MBLOGMASK(MBOX_HOST_INTERFACE_ERROR)) {
6817 xname = "HOST INTERFACE ERROR";
6818 }
6819 break;
6820 case MBOX_TEST_FAILED:
6821 if (mbp->logval & MBLOGMASK(MBOX_TEST_FAILED)) {
6822 xname = "TEST FAILED";
6823 }
6824 break;
6825 case MBOX_COMMAND_ERROR:
6826 if (mbp->logval & MBLOGMASK(MBOX_COMMAND_ERROR)) {
6827 xname = "COMMAND ERROR";
6828 }
6829 break;
6830 case MBOX_COMMAND_PARAM_ERROR:
6831 if (mbp->logval & MBLOGMASK(MBOX_COMMAND_PARAM_ERROR)) {
6832 xname = "COMMAND PARAMETER ERROR";
6833 }
6834 break;
6835 case MBOX_LOOP_ID_USED:
6836 if (mbp->logval & MBLOGMASK(MBOX_LOOP_ID_USED)) {
6837 xname = "LOOP ID ALREADY IN USE";
6838 }
6839 break;
6840 case MBOX_PORT_ID_USED:
6841 if (mbp->logval & MBLOGMASK(MBOX_PORT_ID_USED)) {
6842 xname = "PORT ID ALREADY IN USE";
6843 }
6844 break;
6845 case MBOX_ALL_IDS_USED:
6846 if (mbp->logval & MBLOGMASK(MBOX_ALL_IDS_USED)) {
6847 xname = "ALL LOOP IDS IN USE";
6848 }
6849 break;
6850 case MBOX_REGS_BUSY:
6851 xname = "REGISTERS BUSY";
6852 break;
6853 case MBOX_TIMEOUT:
6854 xname = "TIMEOUT";
6855 break;
6856 default:
6857 SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
6858 xname = mname;
6859 break;
6860 }
6861 if (xname) {
6862 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s)",
6863 cname, xname);
6864 }
6865}
6866
6867static void
6868isp_fw_state(ispsoftc_t *isp)
6869{
6870 if (IS_FC(isp)) {
6871 mbreg_t mbs;
6872 fcparam *fcp = isp->isp_param;
6873
6874 MEMZERO(&mbs, sizeof (mbs));
6875 mbs.param[0] = MBOX_GET_FW_STATE;
6876 mbs.logval = MBLOGALL;
6877 isp_mboxcmd(isp, &mbs);
6878 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
6879 fcp->isp_fwstate = mbs.param[1];
6880 }
6881 }
6882}
6883
6884static void
6885isp_update(ispsoftc_t *isp)
6886{
6887 int bus, upmask;
6888
6889 for (bus = 0, upmask = isp->isp_update; upmask != 0; bus++) {
6890 if (upmask & (1 << bus)) {
6891 isp_update_bus(isp, bus);
6892 }
6893 upmask &= ~(1 << bus);
6894 }
6895}
6896
6897static void
6898isp_update_bus(ispsoftc_t *isp, int bus)
6899{
6900 int tgt;
6901 mbreg_t mbs;
6902 sdparam *sdp;
6903
6904 isp->isp_update &= ~(1 << bus);
6905 if (IS_FC(isp)) {
6906 /*
6907 * There are no 'per-bus' settings for Fibre Channel.
6908 */
6909 return;
6910 }
6911 sdp = isp->isp_param;
6912 sdp += bus;
6913
6914 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
6915 uint16_t flags, period, offset;
6916 int get;
6917
6918 if (sdp->isp_devparam[tgt].dev_enable == 0) {
6919 sdp->isp_devparam[tgt].dev_update = 0;
6920 sdp->isp_devparam[tgt].dev_refresh = 0;
6921 isp_prt(isp, ISP_LOGDEBUG0,
6922 "skipping target %d bus %d update", tgt, bus);
6923 continue;
6924 }
6925 /*
6926 * If the goal is to update the status of the device,
6927 * take what's in goal_flags and try and set the device
6928 * toward that. Otherwise, if we're just refreshing the
6929 * current device state, get the current parameters.
6930 */
6931
6932 MEMZERO(&mbs, sizeof (mbs));
6933
6934 /*
6935 * Refresh overrides set
6936 */
6937 if (sdp->isp_devparam[tgt].dev_refresh) {
6938 mbs.param[0] = MBOX_GET_TARGET_PARAMS;
6939 get = 1;
6940 } else if (sdp->isp_devparam[tgt].dev_update) {
6941 mbs.param[0] = MBOX_SET_TARGET_PARAMS;
6942
6943 /*
6944 * Make sure goal_flags has "Renegotiate on Error"
6945 * on and "Freeze Queue on Error" off.
6946 */
6947 sdp->isp_devparam[tgt].goal_flags |= DPARM_RENEG;
6948 sdp->isp_devparam[tgt].goal_flags &= ~DPARM_QFRZ;
6949 mbs.param[2] = sdp->isp_devparam[tgt].goal_flags;
6950
6951 /*
6952 * Insist that PARITY must be enabled
6953 * if SYNC or WIDE is enabled.
6954 */
6955 if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) {
6956 mbs.param[2] |= DPARM_PARITY;
6957 }
6958
6959 if (mbs.param[2] & DPARM_SYNC) {
6960 mbs.param[3] =
6961 (sdp->isp_devparam[tgt].goal_offset << 8) |
6962 (sdp->isp_devparam[tgt].goal_period);
6963 }
6964 /*
6965 * A command completion later that has
6966 * RQSTF_NEGOTIATION set can cause
6967 * the dev_refresh/announce cycle also.
6968 *
6969 * Note: It is really important to update our current
6970 * flags with at least the state of TAG capabilities-
6971 * otherwise we might try and send a tagged command
6972 * when we have it all turned off. So change it here
6973 * to say that current already matches goal.
6974 */
6975 sdp->isp_devparam[tgt].actv_flags &= ~DPARM_TQING;
6976 sdp->isp_devparam[tgt].actv_flags |=
6977 (sdp->isp_devparam[tgt].goal_flags & DPARM_TQING);
6978 isp_prt(isp, ISP_LOGDEBUG0,
6979 "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
6980 bus, tgt, mbs.param[2], mbs.param[3] >> 8,
6981 mbs.param[3] & 0xff);
6982 get = 0;
6983 } else {
6984 continue;
6985 }
6986 mbs.param[1] = (bus << 15) | (tgt << 8);
6987 mbs.logval = MBLOGALL;
6988 isp_mboxcmd(isp, &mbs);
6989 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
6990 continue;
6991 }
6992 if (get == 0) {
6993 isp->isp_sendmarker |= (1 << bus);
6994 sdp->isp_devparam[tgt].dev_update = 0;
6995 sdp->isp_devparam[tgt].dev_refresh = 1;
6996 } else {
6997 sdp->isp_devparam[tgt].dev_refresh = 0;
6998 flags = mbs.param[2];
6999 period = mbs.param[3] & 0xff;
7000 offset = mbs.param[3] >> 8;
7001 sdp->isp_devparam[tgt].actv_flags = flags;
7002 sdp->isp_devparam[tgt].actv_period = period;
7003 sdp->isp_devparam[tgt].actv_offset = offset;
7004 get = (bus << 16) | tgt;
7005 (void) isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &get);
7006 }
7007 }
7008
7009 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7010 if (sdp->isp_devparam[tgt].dev_update ||
7011 sdp->isp_devparam[tgt].dev_refresh) {
7012 isp->isp_update |= (1 << bus);
7013 break;
7014 }
7015 }
7016}
7017
7018#ifndef DEFAULT_FRAMESIZE
7019#define DEFAULT_FRAMESIZE(isp) ICB_DFLT_FRMLEN
7020#endif
7021#ifndef DEFAULT_EXEC_THROTTLE
7022#define DEFAULT_EXEC_THROTTLE(isp) ISP_EXEC_THROTTLE
7023#endif
7024
7025static void
7026isp_setdfltparm(ispsoftc_t *isp, int channel)
7027{
7028 int tgt;
7029 sdparam *sdp;
7030
7031 if (IS_FC(isp)) {
7032 fcparam *fcp = (fcparam *) isp->isp_param;
7033 int nvfail;
7034
7035 fcp += channel;
7036 if (fcp->isp_gotdparms) {
7037 return;
7038 }
7039 fcp->isp_gotdparms = 1;
7040 fcp->isp_maxfrmlen = DEFAULT_FRAMESIZE(isp);
7041 fcp->isp_maxalloc = ICB_DFLT_ALLOC;
7042 fcp->isp_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
7043 fcp->isp_retry_delay = ICB_DFLT_RDELAY;
7044 fcp->isp_retry_count = ICB_DFLT_RCOUNT;
7045 /* Platform specific.... */
7046 fcp->isp_loopid = DEFAULT_LOOPID(isp);
7047 fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp);
7048 fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp);
7049 fcp->isp_fwoptions = 0;
7050 fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
7051 fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
7052 fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
7053 fcp->isp_fwoptions |= ICBOPT_FAST_POST;
7054 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX) {
7055 fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
7056 }
7057
7058 /*
7059 * Make sure this is turned off now until we get
7060 * extended options from NVRAM
7061 */
7062 fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
7063
7064 /*
7065 * Now try and read NVRAM unless told to not do so.
7066 * This will set fcparam's isp_wwnn_nvram && isp_wwpn_nvram.
7067 */
7068 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7069 nvfail = isp_read_nvram(isp);
7070 if (nvfail) {
7071 isp->isp_confopts |= ISP_CFG_NONVRAM;
7072 }
7073 } else {
7074 nvfail = 1;
7075 }
7076 /*
7077 * Set node && port to override platform set defaults
7078 * unless the nvram read failed (or none was done),
7079 * or the platform code wants to use what had been
7080 * set in the defaults.
7081 */
7082 if (nvfail) {
7083 isp->isp_confopts |= ISP_CFG_OWNWWPN|ISP_CFG_OWNWWNN;
7084 }
7085 if (isp->isp_confopts & ISP_CFG_OWNWWNN) {
7086 isp_prt(isp, ISP_LOGCONFIG, "Using Node WWN 0x%08x%08x",
7087 (uint32_t) (DEFAULT_NODEWWN(isp) >> 32),
7088 (uint32_t) (DEFAULT_NODEWWN(isp) & 0xffffffff));
7089 ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp);
7090 } else {
7091 /*
7092 * We always start out with values derived
7093 * from NVRAM or our platform default.
7094 */
7095 ISP_NODEWWN(isp) = fcp->isp_wwnn_nvram;
7096 if (fcp->isp_wwnn_nvram == 0) {
7097 isp_prt(isp, ISP_LOGCONFIG,
7098 "bad WWNN- using default");
7099 ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp);
7100 }
7101 }
7102 if (isp->isp_confopts & ISP_CFG_OWNWWPN) {
7103 isp_prt(isp, ISP_LOGCONFIG, "Using Port WWN 0x%08x%08x",
7104 (uint32_t) (DEFAULT_PORTWWN(isp) >> 32),
7105 (uint32_t) (DEFAULT_PORTWWN(isp) & 0xffffffff));
7106 ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp);
7107 } else {
7108 /*
7109 * We always start out with values derived
7110 * from NVRAM or our platform default.
7111 */
7112 ISP_PORTWWN(isp) = fcp->isp_wwpn_nvram;
7113 if (fcp->isp_wwpn_nvram == 0) {
7114 isp_prt(isp, ISP_LOGCONFIG,
7115 "bad WWPN- using default");
7116 ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp);
7117 }
7118 }
7119 return;
7120 }
7121
7122 sdp = (sdparam *) isp->isp_param;
7123 sdp += channel;
7124
7125 /*
7126 * Been there, done that, got the T-shirt...
7127 */
7128 if (sdp->isp_gotdparms) {
7129 return;
7130 }
7131 sdp->isp_gotdparms = 1;
7132
7133 /*
7134 * Establish some default parameters.
7135 */
7136 sdp->isp_cmd_dma_burst_enable = 0;
7137 sdp->isp_data_dma_burst_enabl = 1;
7138 sdp->isp_fifo_threshold = 0;
7139 sdp->isp_initiator_id = DEFAULT_IID(isp);
7140 if (isp->isp_type >= ISP_HA_SCSI_1040) {
7141 sdp->isp_async_data_setup = 9;
7142 } else {
7143 sdp->isp_async_data_setup = 6;
7144 }
7145 sdp->isp_selection_timeout = 250;
7146 sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
7147 sdp->isp_tag_aging = 8;
7148 sdp->isp_bus_reset_delay = 5;
7149 /*
7150 * Don't retry selection, busy or queue full automatically- reflect
7151 * these back to us.
7152 */
7153 sdp->isp_retry_count = 0;
7154 sdp->isp_retry_delay = 0;
7155
7156 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7157 sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE;
7158 sdp->isp_devparam[tgt].dev_enable = 1;
7159 }
7160
7161 /*
7162 * If we've not been told to avoid reading NVRAM, try and read it.
7163 * If we're successful reading it, we can then return because NVRAM
7164 * will tell us what the desired settings are. Otherwise, we establish
7165 * some reasonable 'fake' nvram and goal defaults.
7166 */
7167
7168 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7169 if (isp_read_nvram(isp) == 0) {
7170 return;
7171 }
7172 }
7173
7174 /*
7175 * Now try and see whether we have specific values for them.
7176 */
7177 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7178 mbreg_t mbs;
7179
7180 MEMZERO(&mbs, sizeof (mbs));
7181 mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
7182 mbs.logval = MBLOGNONE;
7183 isp_mboxcmd(isp, &mbs);
7184 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
7185 sdp->isp_req_ack_active_neg = 1;
7186 sdp->isp_data_line_active_neg = 1;
7187 } else {
7188 sdp->isp_req_ack_active_neg =
7189 (mbs.param[1+channel] >> 4) & 0x1;
7190 sdp->isp_data_line_active_neg =
7191 (mbs.param[1+channel] >> 5) & 0x1;
7192 }
7193 }
7194
7195 isp_prt(isp, ISP_LOGDEBUG0, sc0, sc3,
7196 0, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
7197 sdp->isp_bus_reset_delay, sdp->isp_retry_count,
7198 sdp->isp_retry_delay, sdp->isp_async_data_setup);
7199 isp_prt(isp, ISP_LOGDEBUG0, sc1, sc3,
7200 sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
7201 sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
7202 sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
7203
7204 /*
7205 * The trick here is to establish a default for the default (honk!)
7206 * state (goal_flags). Then try and get the current status from
7207 * the card to fill in the current state. We don't, in fact, set
7208 * the default to the SAFE default state- that's not the goal state.
7209 */
7210 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7211 uint8_t off, per;
7212 sdp->isp_devparam[tgt].actv_offset = 0;
7213 sdp->isp_devparam[tgt].actv_period = 0;
7214 sdp->isp_devparam[tgt].actv_flags = 0;
7215
7216 sdp->isp_devparam[tgt].goal_flags =
7217 sdp->isp_devparam[tgt].nvrm_flags = DPARM_DEFAULT;
7218
7219 /*
7220 * We default to Wide/Fast for versions less than a 1040
7221 * (unless it's SBus).
7222 */
7223 if (IS_ULTRA3(isp)) {
7224 off = ISP_80M_SYNCPARMS >> 8;
7225 per = ISP_80M_SYNCPARMS & 0xff;
7226 } else if (IS_ULTRA2(isp)) {
7227 off = ISP_40M_SYNCPARMS >> 8;
7228 per = ISP_40M_SYNCPARMS & 0xff;
7229 } else if (IS_1240(isp)) {
7230 off = ISP_20M_SYNCPARMS >> 8;
7231 per = ISP_20M_SYNCPARMS & 0xff;
7232 } else if ((isp->isp_bustype == ISP_BT_SBUS &&
7233 isp->isp_type < ISP_HA_SCSI_1020A) ||
7234 (isp->isp_bustype == ISP_BT_PCI &&
7235 isp->isp_type < ISP_HA_SCSI_1040) ||
7236 (isp->isp_clock && isp->isp_clock < 60) ||
7237 (sdp->isp_ultramode == 0)) {
7238 off = ISP_10M_SYNCPARMS >> 8;
7239 per = ISP_10M_SYNCPARMS & 0xff;
7240 } else {
7241 off = ISP_20M_SYNCPARMS_1040 >> 8;
7242 per = ISP_20M_SYNCPARMS_1040 & 0xff;
7243 }
7244 sdp->isp_devparam[tgt].goal_offset =
7245 sdp->isp_devparam[tgt].nvrm_offset = off;
7246 sdp->isp_devparam[tgt].goal_period =
7247 sdp->isp_devparam[tgt].nvrm_period = per;
7248
7249 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc3,
7250 channel, tgt, sdp->isp_devparam[tgt].nvrm_flags,
7251 sdp->isp_devparam[tgt].nvrm_offset,
7252 sdp->isp_devparam[tgt].nvrm_period);
7253 }
7254}
7255
7256/*
7257 * Re-initialize the ISP and complete all orphaned commands
7258 * with a 'botched' notice. The reset/init routines should
7259 * not disturb an already active list of commands.
7260 */
7261
7262void
7263isp_reinit(ispsoftc_t *isp)
7264{
7265 XS_T *xs;
7266 uint32_t tmp;
7267
7268 if (IS_FC(isp)) {
7269 ISP_MARK_PORTDB(isp, 0);
7270 }
7271 isp_reset(isp);
7272 if (isp->isp_state != ISP_RESETSTATE) {
7273 isp_prt(isp, ISP_LOGERR, "isp_reinit cannot reset card");
7274 } else if (isp->isp_role != ISP_ROLE_NONE) {
7275 isp_init(isp);
7276 if (isp->isp_state == ISP_INITSTATE) {
7277 isp->isp_state = ISP_RUNSTATE;
7278 }
7279 if (isp->isp_state != ISP_RUNSTATE) {
7280 isp_prt(isp, ISP_LOGERR,
7281 "isp_reinit cannot restart card");
7282 ISP_DISABLE_INTS(isp);
7283 }
7284 } else {
7285 ISP_DISABLE_INTS(isp);
7286 if (IS_FC(isp)) {
7287 /*
7288 * If we're in ISP_ROLE_NONE, turn off the lasers.
7289 */
7290 if (!IS_24XX(isp)) {
7291 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
7292 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
7293 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
7294 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
7295 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
7296 }
7297 }
7298 }
7299 isp->isp_nactive = 0;
7300
7301 for (tmp = 0; tmp < isp->isp_maxcmds; tmp++) {
7302 uint32_t handle;
7303
7304 xs = isp->isp_xflist[tmp];
7305 if (xs == NULL) {
7306 continue;
7307 }
7308 handle = isp_find_handle(isp, xs);
7309 if (handle == 0) {
7310 continue;
7311 }
7312 isp_destroy_handle(isp, handle);
7313 if (XS_XFRLEN(xs)) {
7314 ISP_DMAFREE(isp, xs, handle);
7315 XS_RESID(xs) = XS_XFRLEN(xs);
7316 } else {
7317 XS_RESID(xs) = 0;
7318 }
7319 XS_SETERR(xs, HBA_BUSRESET);
7320 isp_done(xs);
7321 }
7322#ifdef ISP_TARGET_MODE
7323 MEMZERO(isp->isp_tgtlist, isp->isp_maxcmds * sizeof (void **));
7324#endif
7325}
7326
7327/*
7328 * NVRAM Routines
7329 */
7330static int
7331isp_read_nvram(ispsoftc_t *isp)
7332{
7333 int i, amt, retval;
7334 uint8_t csum, minversion;
7335 union {
7336 uint8_t _x[ISP2100_NVRAM_SIZE];
7337 uint16_t _s[ISP2100_NVRAM_SIZE>>1];
7338 } _n;
7339#define nvram_data _n._x
7340#define nvram_words _n._s
7341
7342 if (IS_24XX(isp)) {
7343 return (isp_read_nvram_2400(isp));
7344 } else if (IS_FC(isp)) {
7345 amt = ISP2100_NVRAM_SIZE;
7346 minversion = 1;
7347 } else if (IS_ULTRA2(isp)) {
7348 amt = ISP1080_NVRAM_SIZE;
7349 minversion = 0;
7350 } else {
7351 amt = ISP_NVRAM_SIZE;
7352 minversion = 2;
7353 }
7354
7355 for (i = 0; i < amt>>1; i++) {
7356 isp_rdnvram_word(isp, i, &nvram_words[i]);
7357 }
7358
7359 if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7360 nvram_data[2] != 'P') {
7361 if (isp->isp_bustype != ISP_BT_SBUS) {
7362 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
7363 isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x",
7364 nvram_data[0], nvram_data[1], nvram_data[2]);
7365 }
7366 retval = -1;
7367 goto out;
7368 }
7369
7370 for (csum = 0, i = 0; i < amt; i++) {
7371 csum += nvram_data[i];
7372 }
7373 if (csum != 0) {
7374 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7375 retval = -1;
7376 goto out;
7377 }
7378
7379 if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
7380 isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
7381 ISP_NVRAM_VERSION(nvram_data));
7382 retval = -1;
7383 goto out;
7384 }
7385
7386 if (IS_ULTRA3(isp)) {
7387 isp_parse_nvram_12160(isp, 0, nvram_data);
7388 if (IS_12160(isp))
7389 isp_parse_nvram_12160(isp, 1, nvram_data);
7390 } else if (IS_1080(isp)) {
7391 isp_parse_nvram_1080(isp, 0, nvram_data);
7392 } else if (IS_1280(isp) || IS_1240(isp)) {
7393 isp_parse_nvram_1080(isp, 0, nvram_data);
7394 isp_parse_nvram_1080(isp, 1, nvram_data);
7395 } else if (IS_SCSI(isp)) {
7396 isp_parse_nvram_1020(isp, nvram_data);
7397 } else {
7398 isp_parse_nvram_2100(isp, nvram_data);
7399 }
7400 retval = 0;
7401out:
7402 return (retval);
7403#undef nvram_data
7404#undef nvram_words
7405}
7406
7407static int
7408isp_read_nvram_2400(ispsoftc_t *isp)
7409{
7410 uint8_t *nvram_data = FCPARAM(isp)->isp_scratch;
7411 int retval = 0;
7412 uint32_t addr, csum, lwrds, *dptr;
7413
7414 if (isp->isp_port) {
7415 addr = ISP2400_NVRAM_PORT1_ADDR;
7416 } else {
7417 addr = ISP2400_NVRAM_PORT0_ADDR;
7418 }
7419
7420 dptr = (uint32_t *) nvram_data;
7421 for (lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7422 isp_rd_2400_nvram(isp, addr++, dptr++);
7423 }
7424 if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7425 nvram_data[2] != 'P') {
7426 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
7427 retval = -1;
7428 goto out;
7429 }
7430 dptr = (uint32_t *) nvram_data;
7431 for (csum = 0, lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7432 csum += dptr[lwrds];
7433 }
7434 if (csum != 0) {
7435 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7436 retval = -1;
7437 goto out;
7438 }
7439 isp_parse_nvram_2400(isp, nvram_data);
7440out:
7441 return (retval);
7442}
7443
7444static void
7445isp_rdnvram_word(ispsoftc_t *isp, int wo, uint16_t *rp)
7446{
7447 int i, cbits;
7448 uint16_t bit, rqst, junk;
7449
7450 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7451 USEC_DELAY(10);
7452 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7453 USEC_DELAY(10);
7454
7455 if (IS_FC(isp)) {
7456 wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
7457 if (IS_2312(isp) && isp->isp_port) {
7458 wo += 128;
7459 }
7460 rqst = (ISP_NVRAM_READ << 8) | wo;
7461 cbits = 10;
7462 } else if (IS_ULTRA2(isp)) {
7463 wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1);
7464 rqst = (ISP_NVRAM_READ << 8) | wo;
7465 cbits = 10;
7466 } else {
7467 wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
7468 rqst = (ISP_NVRAM_READ << 6) | wo;
7469 cbits = 8;
7470 }
7471
7472 /*
7473 * Clock the word select request out...
7474 */
7475 for (i = cbits; i >= 0; i--) {
7476 if ((rqst >> i) & 1) {
7477 bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
7478 } else {
7479 bit = BIU_NVRAM_SELECT;
7480 }
7481 ISP_WRITE(isp, BIU_NVRAM, bit);
7482 USEC_DELAY(10);
7483 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7484 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
7485 USEC_DELAY(10);
7486 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7487 ISP_WRITE(isp, BIU_NVRAM, bit);
7488 USEC_DELAY(10);
7489 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7490 }
7491 /*
7492 * Now read the result back in (bits come back in MSB format).
7493 */
7494 *rp = 0;
7495 for (i = 0; i < 16; i++) {
7496 uint16_t rv;
7497 *rp <<= 1;
7498 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7499 USEC_DELAY(10);
7500 rv = ISP_READ(isp, BIU_NVRAM);
7501 if (rv & BIU_NVRAM_DATAIN) {
7502 *rp |= 1;
7503 }
7504 USEC_DELAY(10);
7505 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7506 USEC_DELAY(10);
7507 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7508 }
7509 ISP_WRITE(isp, BIU_NVRAM, 0);
7510 USEC_DELAY(10);
7511 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7512 ISP_SWIZZLE_NVRAM_WORD(isp, rp);
7513}
7514
7515static void
7516isp_rd_2400_nvram(ispsoftc_t *isp, uint32_t addr, uint32_t *rp)
7517{
7518 int loops = 0;
7519 const uint32_t base = 0x7ffe0000;
7520 uint32_t tmp;
7521
7522 ISP_WRITE(isp, BIU2400_FLASH_ADDR, base | addr);
7523 for (loops = 0; loops < 5000; loops++) {
7524 USEC_DELAY(10);
7525 tmp = ISP_READ(isp, BIU2400_FLASH_ADDR);
| 4562 }
4563 }
4564
4565 /*
4566 * We can't be getting this now.
4567 */
4568 if (isp->isp_state != ISP_RUNSTATE) {
4569 isp_prt(isp, ISP_LOGINFO,
4570 "interrupt (ISR=%x SEMA=%x) when not ready", isr, sema);
4571 /*
4572 * Thank you very much! *Burrrp*!
4573 */
4574 ISP_WRITE(isp, isp->isp_respoutrp,
4575 ISP_READ(isp, isp->isp_respinrp));
4576 if (IS_24XX(isp)) {
4577 ISP_DISABLE_INTS(isp);
4578 }
4579 goto out;
4580 }
4581
4582#ifdef ISP_TARGET_MODE
4583 /*
4584 * Check for ATIO Queue entries.
4585 */
4586 if (isp->isp_rspbsy == 0 && (isp->isp_role & ISP_ROLE_TARGET) &&
4587 IS_24XX(isp)) {
4588 iptr = ISP_READ(isp, isp->isp_atioinrp);
4589 optr = ISP_READ(isp, isp->isp_atiooutrp);
4590
4591 isp->isp_rspbsy = 1;
4592 while (optr != iptr) {
4593 uint8_t qe[QENTRY_LEN];
4594 isphdr_t *hp;
4595 uint32_t oop;
4596 void *addr;
4597
4598 oop = optr;
4599 MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN);
4600 addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
4601 isp_get_hdr(isp, addr, (isphdr_t *)qe);
4602 hp = (isphdr_t *)qe;
4603 switch (hp->rqs_entry_type) {
4604 case RQSTYPE_NOTIFY:
4605 case RQSTYPE_ATIO:
4606 (void) isp_target_notify(isp, addr, &oop);
4607 break;
4608 default:
4609 isp_print_qentry(isp, "?ATIOQ entry?",
4610 oop, addr);
4611 break;
4612 }
4613 optr = ISP_NXT_QENTRY(oop, RESULT_QUEUE_LEN(isp));
4614 ISP_WRITE(isp, isp->isp_atiooutrp, optr);
4615 }
4616 isp->isp_rspbsy = 0;
4617 }
4618#endif
4619
4620 /*
4621 * Get the current Response Queue Out Pointer.
4622 *
4623 * If we're a 2300 or 2400, we can ask what hardware what it thinks.
4624 */
4625 if (IS_23XX(isp) || IS_24XX(isp)) {
4626 optr = ISP_READ(isp, isp->isp_respoutrp);
4627 /*
4628 * Debug: to be taken out eventually
4629 */
4630 if (isp->isp_residx != optr) {
4631 isp_prt(isp, ISP_LOGINFO,
4632 "isp_intr: hard optr=%x, soft optr %x",
4633 optr, isp->isp_residx);
4634 isp->isp_residx = optr;
4635 }
4636 } else {
4637 optr = isp->isp_residx;
4638 }
4639
4640 /*
4641 * You *must* read the Response Queue In Pointer
4642 * prior to clearing the RISC interrupt.
4643 *
4644 * Debounce the 2300 if revision less than 2.
4645 */
4646 if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
4647 i = 0;
4648 do {
4649 iptr = ISP_READ(isp, isp->isp_respinrp);
4650 junk = ISP_READ(isp, isp->isp_respinrp);
4651 } while (junk != iptr && ++i < 1000);
4652
4653 if (iptr != junk) {
4654 isp_prt(isp, ISP_LOGWARN,
4655 "Response Queue Out Pointer Unstable (%x, %x)",
4656 iptr, junk);
4657 goto out;
4658 }
4659 } else {
4660 iptr = ISP_READ(isp, isp->isp_respinrp);
4661 }
4662 isp->isp_resodx = iptr;
4663
4664
4665 if (optr == iptr && sema == 0) {
4666 /*
4667 * There are a lot of these- reasons unknown- mostly on
4668 * faster Alpha machines.
4669 *
4670 * I tried delaying after writing HCCR_CMD_CLEAR_RISC_INT to
4671 * make sure the old interrupt went away (to avoid 'ringing'
4672 * effects), but that didn't stop this from occurring.
4673 */
4674 if (IS_24XX(isp)) {
4675 junk = 0;
4676 } else if (IS_23XX(isp)) {
4677 USEC_DELAY(100);
4678 iptr = ISP_READ(isp, isp->isp_respinrp);
4679 junk = ISP_READ(isp, BIU_R2HSTSLO);
4680 } else {
4681 junk = ISP_READ(isp, BIU_ISR);
4682 }
4683 if (optr == iptr) {
4684 if (IS_23XX(isp) || IS_24XX(isp)) {
4685 ;
4686 } else {
4687 sema = ISP_READ(isp, BIU_SEMA);
4688 mbox = ISP_READ(isp, OUTMAILBOX0);
4689 if ((sema & 0x3) && (mbox & 0x8000)) {
4690 goto again;
4691 }
4692 }
4693 isp->isp_intbogus++;
4694 isp_prt(isp, ISP_LOGDEBUG1,
4695 "bogus intr- isr %x (%x) iptr %x optr %x",
4696 isr, junk, iptr, optr);
4697 }
4698 }
4699 isp->isp_resodx = iptr;
4700
4701
4702 if (isp->isp_rspbsy) {
4703 goto out;
4704 }
4705 isp->isp_rspbsy = 1;
4706 while (optr != iptr) {
4707 uint8_t qe[QENTRY_LEN];
4708 ispstatusreq_t *sp = (ispstatusreq_t *) qe;
4709 isphdr_t *hp;
4710 int buddaboom, etype, scsi_status, completion_status;
4711 int req_status_flags, req_state_flags;
4712 uint8_t *snsp, *resp;
4713 uint32_t rlen, slen;
4714 long resid;
4715 uint16_t oop;
4716
4717 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
4718 oop = optr;
4719 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
4720 nlooked++;
4721 read_again:
4722 buddaboom = req_status_flags = req_state_flags = 0;
4723 resid = 0L;
4724
4725 /*
4726 * Synchronize our view of this response queue entry.
4727 */
4728 MEMORYBARRIER(isp, SYNC_RESULT, oop, QENTRY_LEN);
4729 isp_get_hdr(isp, hp, &sp->req_header);
4730 etype = sp->req_header.rqs_entry_type;
4731
4732 if (IS_24XX(isp) && etype == RQSTYPE_T7RQS) {
4733 isp24xx_statusreq_t *sp2 = (isp24xx_statusreq_t *)qe;
4734 isp_get_24xx_response(isp,
4735 (isp24xx_statusreq_t *)hp, sp2);
4736 if (isp->isp_dblev & ISP_LOGDEBUG1) {
4737 isp_print_bytes(isp,
4738 "Response Queue Entry", QENTRY_LEN, sp2);
4739 }
4740 scsi_status = sp2->req_scsi_status;
4741 completion_status = sp2->req_completion_status;
4742 req_state_flags = 0;
4743 resid = sp2->req_resid;
4744 } else if (etype == RQSTYPE_RESPONSE) {
4745 isp_get_response(isp, (ispstatusreq_t *) hp, sp);
4746 if (isp->isp_dblev & ISP_LOGDEBUG1) {
4747 isp_print_bytes(isp,
4748 "Response Queue Entry", QENTRY_LEN, sp);
4749 }
4750 scsi_status = sp->req_scsi_status;
4751 completion_status = sp->req_completion_status;
4752 req_status_flags = sp->req_status_flags;
4753 req_state_flags = sp->req_state_flags;
4754 resid = sp->req_resid;
4755 } else if (etype == RQSTYPE_RIO2) {
4756 isp_rio2_t *rio = (isp_rio2_t *)qe;
4757 isp_get_rio2(isp, (isp_rio2_t *) hp, rio);
4758 if (isp->isp_dblev & ISP_LOGDEBUG1) {
4759 isp_print_bytes(isp,
4760 "Response Queue Entry", QENTRY_LEN, rio);
4761 }
4762 for (i = 0; i < rio->req_header.rqs_seqno; i++) {
4763 isp_fastpost_complete(isp, rio->req_handles[i]);
4764 }
4765 if (isp->isp_fpcchiwater < rio->req_header.rqs_seqno) {
4766 isp->isp_fpcchiwater =
4767 rio->req_header.rqs_seqno;
4768 }
4769 MEMZERO(hp, QENTRY_LEN); /* PERF */
4770 continue;
4771 } else {
4772 /*
4773 * Somebody reachable via isp_handle_other_response
4774 * may have updated the response queue pointers for
4775 * us, so we reload our goal index.
4776 */
4777 int r;
4778 r = isp_handle_other_response(isp, etype, hp, &optr);
4779 if (r < 0) {
4780 goto read_again;
4781 }
4782 if (r > 0) {
4783 iptr = isp->isp_resodx;
4784 MEMZERO(hp, QENTRY_LEN); /* PERF */
4785 continue;
4786 }
4787
4788 /*
4789 * After this point, we'll just look at the header as
4790 * we don't know how to deal with the rest of the
4791 * response.
4792 */
4793
4794 /*
4795 * It really has to be a bounced request just copied
4796 * from the request queue to the response queue. If
4797 * not, something bad has happened.
4798 */
4799 if (etype != RQSTYPE_REQUEST) {
4800 isp_prt(isp, ISP_LOGERR, notresp,
4801 etype, oop, optr, nlooked);
4802 isp_print_bytes(isp,
4803 "Reqeonse Queue Entry", QENTRY_LEN, sp);
4804 MEMZERO(hp, QENTRY_LEN); /* PERF */
4805 continue;
4806 }
4807 buddaboom = 1;
4808 scsi_status = sp->req_scsi_status;
4809 completion_status = sp->req_completion_status;
4810 req_status_flags = sp->req_status_flags;
4811 req_state_flags = sp->req_state_flags;
4812 resid = sp->req_resid;
4813 }
4814
4815 if (sp->req_header.rqs_flags & RQSFLAG_MASK) {
4816 if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
4817 isp_prt(isp, ISP_LOGWARN,
4818 "continuation segment");
4819 ISP_WRITE(isp, isp->isp_respoutrp, optr);
4820 continue;
4821 }
4822 if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
4823 isp_prt(isp, ISP_LOGDEBUG1,
4824 "internal queues full");
4825 /*
4826 * We'll synthesize a QUEUE FULL message below.
4827 */
4828 }
4829 if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
4830 isp_print_bytes(isp, "bad header flag",
4831 QENTRY_LEN, sp);
4832 buddaboom++;
4833 }
4834 if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
4835 isp_print_bytes(isp, "bad request packet",
4836 QENTRY_LEN, sp);
4837 buddaboom++;
4838 }
4839 }
4840
4841 if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) {
4842 isp_prt(isp, ISP_LOGERR,
4843 "bad request handle %d (type 0x%x)",
4844 sp->req_handle, etype);
4845 MEMZERO(hp, QENTRY_LEN); /* PERF */
4846 ISP_WRITE(isp, isp->isp_respoutrp, optr);
4847 continue;
4848 }
4849 xs = isp_find_xs(isp, sp->req_handle);
4850 if (xs == NULL) {
4851 uint8_t ts = completion_status & 0xff;
4852 /*
4853 * Only whine if this isn't the expected fallout of
4854 * aborting the command.
4855 */
4856 if (etype != RQSTYPE_RESPONSE) {
4857 isp_prt(isp, ISP_LOGERR,
4858 "cannot find handle 0x%x (type 0x%x)",
4859 sp->req_handle, etype);
4860 } else if (ts != RQCS_ABORTED) {
4861 isp_prt(isp, ISP_LOGERR,
4862 "cannot find handle 0x%x (status 0x%x)",
4863 sp->req_handle, ts);
4864 }
4865 MEMZERO(hp, QENTRY_LEN); /* PERF */
4866 ISP_WRITE(isp, isp->isp_respoutrp, optr);
4867 continue;
4868 }
4869 isp_destroy_handle(isp, sp->req_handle);
4870 if (req_status_flags & RQSTF_BUS_RESET) {
4871 XS_SETERR(xs, HBA_BUSRESET);
4872 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
4873 }
4874 if (buddaboom) {
4875 XS_SETERR(xs, HBA_BOTCH);
4876 }
4877
4878 resp = NULL;
4879 rlen = 0;
4880 snsp = NULL;
4881 slen = 0;
4882 if (IS_24XX(isp) && (scsi_status & RQCS_RV) != 0) {
4883 resp = ((isp24xx_statusreq_t *)sp)->req_rsp_sense;
4884 rlen = ((isp24xx_statusreq_t *)sp)->req_response_len;
4885 } else if (IS_FC(isp) && (scsi_status & RQCS_RV) != 0) {
4886 resp = sp->req_response;
4887 rlen = sp->req_response_len;
4888 }
4889 if (IS_FC(isp) && (scsi_status & RQCS_SV) != 0) {
4890 /*
4891 * Fibre Channel F/W doesn't say we got status
4892 * if there's Sense Data instead. I guess they
4893 * think it goes w/o saying.
4894 */
4895 req_state_flags |= RQSF_GOT_STATUS|RQSF_GOT_SENSE;
4896 if (IS_24XX(isp)) {
4897 snsp =
4898 ((isp24xx_statusreq_t *)sp)->req_rsp_sense;
4899 snsp += rlen;
4900 slen =
4901 ((isp24xx_statusreq_t *)sp)->req_sense_len;
4902 } else {
4903 snsp = sp->req_sense_data;
4904 slen = sp->req_sense_len;
4905 }
4906 } else if (IS_SCSI(isp) && (req_state_flags & RQSF_GOT_SENSE)) {
4907 snsp = sp->req_sense_data;
4908 slen = sp->req_sense_len;
4909 }
4910 if (req_state_flags & RQSF_GOT_STATUS) {
4911 *XS_STSP(xs) = scsi_status & 0xff;
4912 }
4913
4914 switch (etype) {
4915 case RQSTYPE_RESPONSE:
4916 XS_SET_STATE_STAT(isp, xs, sp);
4917 if (resp && rlen >= 4 &&
4918 resp[FCP_RSPNS_CODE_OFFSET] != 0) {
4919 isp_prt(isp, ISP_LOGWARN,
4920 "%d.%d FCP RESPONSE: 0x%x",
4921 XS_TGT(xs), XS_LUN(xs),
4922 resp[FCP_RSPNS_CODE_OFFSET]);
4923 XS_SETERR(xs, HBA_BOTCH);
4924 }
4925 if (IS_24XX(isp)) {
4926 isp_parse_status_24xx(isp,
4927 (isp24xx_statusreq_t *)sp, xs, &resid);
4928 } else {
4929 isp_parse_status(isp, (void *)sp, xs, &resid);
4930 }
4931 if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
4932 (*XS_STSP(xs) == SCSI_BUSY)) {
4933 XS_SETERR(xs, HBA_TGTBSY);
4934 }
4935 if (IS_SCSI(isp)) {
4936 XS_RESID(xs) = resid;
4937 /*
4938 * A new synchronous rate was negotiated for
4939 * this target. Mark state such that we'll go
4940 * look up that which has changed later.
4941 */
4942 if (req_status_flags & RQSTF_NEGOTIATION) {
4943 int t = XS_TGT(xs);
4944 sdparam *sdp = isp->isp_param;
4945 sdp += XS_CHANNEL(xs);
4946 sdp->isp_devparam[t].dev_refresh = 1;
4947 isp->isp_update |=
4948 (1 << XS_CHANNEL(xs));
4949 }
4950 } else {
4951 if (req_status_flags & RQSF_XFER_COMPLETE) {
4952 XS_RESID(xs) = 0;
4953 } else if (scsi_status & RQCS_RESID) {
4954 XS_RESID(xs) = resid;
4955 } else {
4956 XS_RESID(xs) = 0;
4957 }
4958 }
4959 if (snsp && slen) {
4960 XS_SAVE_SENSE(xs, snsp, slen);
4961 }
4962 isp_prt(isp, ISP_LOGDEBUG2,
4963 "asked for %ld got raw resid %ld settled for %ld",
4964 (long) XS_XFRLEN(xs), resid, (long) XS_RESID(xs));
4965 break;
4966 case RQSTYPE_REQUEST:
4967 case RQSTYPE_A64:
4968 case RQSTYPE_T2RQS:
4969 case RQSTYPE_T3RQS:
4970 case RQSTYPE_T7RQS:
4971 if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
4972 /*
4973 * Force Queue Full status.
4974 */
4975 *XS_STSP(xs) = SCSI_QFULL;
4976 XS_SETERR(xs, HBA_NOERROR);
4977 } else if (XS_NOERR(xs)) {
4978 /*
4979 * ????
4980 */
4981 XS_SETERR(xs, HBA_BOTCH);
4982 isp_prt(isp, ISP_LOGDEBUG0,
4983 "Request Queue Entry bounced back");
4984 if ((isp->isp_dblev & ISP_LOGDEBUG1) == 0) {
4985 isp_print_bytes(isp, "Bounced Request",
4986 QENTRY_LEN, qe);
4987 }
4988 }
4989 XS_RESID(xs) = XS_XFRLEN(xs);
4990 break;
4991 default:
4992 isp_print_bytes(isp, "Unhandled Response Type",
4993 QENTRY_LEN, qe);
4994 if (XS_NOERR(xs)) {
4995 XS_SETERR(xs, HBA_BOTCH);
4996 }
4997 break;
4998 }
4999
5000 /*
5001 * Free any DMA resources. As a side effect, this may
5002 * also do any cache flushing necessary for data coherence. */
5003 if (XS_XFRLEN(xs)) {
5004 ISP_DMAFREE(isp, xs, sp->req_handle);
5005 }
5006
5007 if (((isp->isp_dblev & (ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
5008 ((isp->isp_dblev & ISP_LOGDEBUG1) && ((!XS_NOERR(xs)) ||
5009 (*XS_STSP(xs) != SCSI_GOOD)))) {
5010 char skey;
5011 if (req_state_flags & RQSF_GOT_SENSE) {
5012 skey = XS_SNSKEY(xs) & 0xf;
5013 if (skey < 10)
5014 skey += '0';
5015 else
5016 skey += 'a' - 10;
5017 } else if (*XS_STSP(xs) == SCSI_CHECK) {
5018 skey = '?';
5019 } else {
5020 skey = '.';
5021 }
5022 isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs),
5023 XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs), XS_RESID(xs),
5024 *XS_STSP(xs), skey, XS_ERR(xs));
5025 }
5026
5027 if (isp->isp_nactive > 0)
5028 isp->isp_nactive--;
5029 complist[ndone++] = xs; /* defer completion call until later */
5030 MEMZERO(hp, QENTRY_LEN); /* PERF */
5031 if (ndone == MAX_REQUESTQ_COMPLETIONS) {
5032 break;
5033 }
5034 }
5035
5036 /*
5037 * If we looked at any commands, then it's valid to find out
5038 * what the outpointer is. It also is a trigger to update the
5039 * ISP's notion of what we've seen so far.
5040 */
5041 if (nlooked) {
5042 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5043 /*
5044 * While we're at it, read the requst queue out pointer.
5045 */
5046 isp->isp_reqodx = ISP_READ(isp, isp->isp_rqstoutrp);
5047 if (isp->isp_rscchiwater < ndone) {
5048 isp->isp_rscchiwater = ndone;
5049 }
5050 }
5051
5052out:
5053
5054 if (IS_24XX(isp)) {
5055 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
5056 } else {
5057 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
5058 ISP_WRITE(isp, BIU_SEMA, 0);
5059 }
5060
5061 isp->isp_residx = optr;
5062 isp->isp_rspbsy = 0;
5063 for (i = 0; i < ndone; i++) {
5064 xs = complist[i];
5065 if (xs) {
5066 isp->isp_rsltccmplt++;
5067 isp_done(xs);
5068 }
5069 }
5070}
5071
5072/*
5073 * Support routines.
5074 */
5075
5076static int
5077isp_parse_async(ispsoftc_t *isp, uint16_t mbox)
5078{
5079 int rval = 0;
5080 int bus;
5081
5082 if (IS_DUALBUS(isp)) {
5083 bus = ISP_READ(isp, OUTMAILBOX6);
5084 } else {
5085 bus = 0;
5086 }
5087 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5088
5089 switch (mbox) {
5090 case ASYNC_BUS_RESET:
5091 isp->isp_sendmarker |= (1 << bus);
5092#ifdef ISP_TARGET_MODE
5093 if (isp_target_async(isp, bus, mbox)) {
5094 rval = -1;
5095 }
5096#endif
5097 isp_async(isp, ISPASYNC_BUS_RESET, &bus);
5098 break;
5099 case ASYNC_SYSTEM_ERROR:
5100 isp->isp_state = ISP_CRASHED;
5101 if (IS_FC(isp)) {
5102 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
5103 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5104 }
5105 /*
5106 * Were we waiting for a mailbox command to complete?
5107 * If so, it's dead, so wake up the waiter.
5108 */
5109 if (isp->isp_mboxbsy) {
5110 isp->isp_obits = 1;
5111 isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5112 MBOX_NOTIFY_COMPLETE(isp);
5113 }
5114#ifdef ISP_FW_CRASH_DUMP
5115 /*
5116 * If we have crash dumps enabled, it's up to the handler
5117 * for isp_async to reinit stuff and restart the firmware
5118 * after performing the crash dump. The reason we do things
5119 * this way is that we may need to activate a kernel thread
5120 * to do all the crash dump goop.
5121 */
5122 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
5123#else
5124 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
5125 isp_reinit(isp);
5126 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
5127#endif
5128 rval = -1;
5129 break;
5130
5131 case ASYNC_RQS_XFER_ERR:
5132 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5133 break;
5134
5135 case ASYNC_RSP_XFER_ERR:
5136 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5137 break;
5138
5139 case ASYNC_QWAKEUP:
5140 /*
5141 * We've just been notified that the Queue has woken up.
5142 * We don't need to be chatty about this- just unlatch things
5143 * and move on.
5144 */
5145 mbox = ISP_READ(isp, isp->isp_rqstoutrp);
5146 break;
5147
5148 case ASYNC_TIMEOUT_RESET:
5149 isp_prt(isp, ISP_LOGWARN,
5150 "timeout initiated SCSI bus reset of bus %d", bus);
5151 isp->isp_sendmarker |= (1 << bus);
5152#ifdef ISP_TARGET_MODE
5153 if (isp_target_async(isp, bus, mbox)) {
5154 rval = -1;
5155 }
5156#endif
5157 break;
5158
5159 case ASYNC_DEVICE_RESET:
5160 isp_prt(isp, ISP_LOGINFO, "device reset on bus %d", bus);
5161 isp->isp_sendmarker |= (1 << bus);
5162#ifdef ISP_TARGET_MODE
5163 if (isp_target_async(isp, bus, mbox)) {
5164 rval = -1;
5165 }
5166#endif
5167 break;
5168
5169 case ASYNC_EXTMSG_UNDERRUN:
5170 isp_prt(isp, ISP_LOGWARN, "extended message underrun");
5171 break;
5172
5173 case ASYNC_SCAM_INT:
5174 isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
5175 break;
5176
5177 case ASYNC_HUNG_SCSI:
5178 isp_prt(isp, ISP_LOGERR,
5179 "stalled SCSI Bus after DATA Overrun");
5180 /* XXX: Need to issue SCSI reset at this point */
5181 break;
5182
5183 case ASYNC_KILLED_BUS:
5184 isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
5185 break;
5186
5187 case ASYNC_BUS_TRANSIT:
5188 mbox = ISP_READ(isp, OUTMAILBOX2);
5189 switch (mbox & 0x1c00) {
5190 case SXP_PINS_LVD_MODE:
5191 isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
5192 SDPARAM(isp)->isp_diffmode = 0;
5193 SDPARAM(isp)->isp_ultramode = 0;
5194 SDPARAM(isp)->isp_lvdmode = 1;
5195 break;
5196 case SXP_PINS_HVD_MODE:
5197 isp_prt(isp, ISP_LOGINFO,
5198 "Transition to Differential mode");
5199 SDPARAM(isp)->isp_diffmode = 1;
5200 SDPARAM(isp)->isp_ultramode = 0;
5201 SDPARAM(isp)->isp_lvdmode = 0;
5202 break;
5203 case SXP_PINS_SE_MODE:
5204 isp_prt(isp, ISP_LOGINFO,
5205 "Transition to Single Ended mode");
5206 SDPARAM(isp)->isp_diffmode = 0;
5207 SDPARAM(isp)->isp_ultramode = 1;
5208 SDPARAM(isp)->isp_lvdmode = 0;
5209 break;
5210 default:
5211 isp_prt(isp, ISP_LOGWARN,
5212 "Transition to Unknown Mode 0x%x", mbox);
5213 break;
5214 }
5215 /*
5216 * XXX: Set up to renegotiate again!
5217 */
5218 /* Can only be for a 1080... */
5219 isp->isp_sendmarker |= (1 << bus);
5220 break;
5221
5222 /*
5223 * We can use bus, which will always be zero for FC cards,
5224 * as a mailbox pattern accumulator to be checked below.
5225 */
5226 case ASYNC_RIO5:
5227 bus = 0x1ce; /* outgoing mailbox regs 1-3, 6-7 */
5228 break;
5229
5230 case ASYNC_RIO4:
5231 bus = 0x14e; /* outgoing mailbox regs 1-3, 6 */
5232 break;
5233
5234 case ASYNC_RIO3:
5235 bus = 0x10e; /* outgoing mailbox regs 1-3 */
5236 break;
5237
5238 case ASYNC_RIO2:
5239 bus = 0x106; /* outgoing mailbox regs 1-2 */
5240 break;
5241
5242 case ASYNC_RIO1:
5243 case ASYNC_CMD_CMPLT:
5244 bus = 0x102; /* outgoing mailbox regs 1 */
5245 break;
5246
5247 case ASYNC_RIO_RESP:
5248 return (rval);
5249
5250 case ASYNC_CTIO_DONE:
5251 {
5252#ifdef ISP_TARGET_MODE
5253 int handle =
5254 (ISP_READ(isp, OUTMAILBOX2) << 16) |
5255 (ISP_READ(isp, OUTMAILBOX1));
5256 if (isp_target_async(isp, handle, mbox)) {
5257 rval = -1;
5258 } else {
5259 /* count it as a fast posting intr */
5260 isp->isp_fphccmplt++;
5261 }
5262#else
5263 isp_prt(isp, ISP_LOGINFO, "Fast Posting CTIO done");
5264 isp->isp_fphccmplt++; /* count it as a fast posting intr */
5265#endif
5266 break;
5267 }
5268 case ASYNC_LIP_ERROR:
5269 case ASYNC_LIP_F8:
5270 case ASYNC_LIP_OCCURRED:
5271 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5272 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
5273 isp->isp_sendmarker = 1;
5274 ISP_MARK_PORTDB(isp, 1);
5275 isp_async(isp, ISPASYNC_LIP, NULL);
5276#ifdef ISP_TARGET_MODE
5277 if (isp_target_async(isp, bus, mbox)) {
5278 rval = -1;
5279 }
5280#endif
5281 /*
5282 * We've had problems with data corruption occuring on
5283 * commands that complete (with no apparent error) after
5284 * we receive a LIP. This has been observed mostly on
5285 * Local Loop topologies. To be safe, let's just mark
5286 * all active commands as dead.
5287 */
5288 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
5289 FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
5290 int i, j;
5291 for (i = j = 0; i < isp->isp_maxcmds; i++) {
5292 XS_T *xs;
5293 xs = isp->isp_xflist[i];
5294 if (xs != NULL) {
5295 j++;
5296 XS_SETERR(xs, HBA_BUSRESET);
5297 }
5298 }
5299 if (j) {
5300 isp_prt(isp, ISP_LOGERR,
5301 "LIP destroyed %d active commands", j);
5302 }
5303 }
5304 break;
5305
5306 case ASYNC_LOOP_UP:
5307 isp->isp_sendmarker = 1;
5308 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5309 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
5310 ISP_MARK_PORTDB(isp, 1);
5311 isp_async(isp, ISPASYNC_LOOP_UP, NULL);
5312#ifdef ISP_TARGET_MODE
5313 if (isp_target_async(isp, bus, mbox)) {
5314 rval = -1;
5315 }
5316#endif
5317 break;
5318
5319 case ASYNC_LOOP_DOWN:
5320 isp->isp_sendmarker = 1;
5321 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5322 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
5323 ISP_MARK_PORTDB(isp, 1);
5324 isp_async(isp, ISPASYNC_LOOP_DOWN, NULL);
5325#ifdef ISP_TARGET_MODE
5326 if (isp_target_async(isp, bus, mbox)) {
5327 rval = -1;
5328 }
5329#endif
5330 break;
5331
5332 case ASYNC_LOOP_RESET:
5333 isp->isp_sendmarker = 1;
5334 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5335 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
5336 ISP_MARK_PORTDB(isp, 1);
5337 isp_async(isp, ISPASYNC_LOOP_RESET, NULL);
5338#ifdef ISP_TARGET_MODE
5339 if (isp_target_async(isp, bus, mbox)) {
5340 rval = -1;
5341 }
5342#endif
5343 break;
5344
5345 case ASYNC_PDB_CHANGED:
5346 isp->isp_sendmarker = 1;
5347 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
5348 ISP_MARK_PORTDB(isp, 1);
5349 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_PDB);
5350 break;
5351
5352 case ASYNC_CHANGE_NOTIFY:
5353 if (FCPARAM(isp)->isp_topo == TOPO_F_PORT) {
5354 FCPARAM(isp)->isp_loopstate = LOOP_LSCAN_DONE;
5355 } else {
5356 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
5357 }
5358 ISP_MARK_PORTDB(isp, 1);
5359 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_SNS);
5360 break;
5361
5362 case ASYNC_PTPMODE:
5363 ISP_MARK_PORTDB(isp, 1);
5364 isp->isp_sendmarker = 1;
5365 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5366 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
5367 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
5368#ifdef ISP_TARGET_MODE
5369 if (isp_target_async(isp, bus, mbox)) {
5370 rval = -1;
5371 }
5372#endif
5373 isp_prt(isp, ISP_LOGINFO, "Point-to-Point mode");
5374 break;
5375
5376 case ASYNC_CONNMODE:
5377 mbox = ISP_READ(isp, OUTMAILBOX1);
5378 ISP_MARK_PORTDB(isp, 1);
5379 switch (mbox) {
5380 case ISP_CONN_LOOP:
5381 isp_prt(isp, ISP_LOGINFO,
5382 "Point-to-Point -> Loop mode");
5383 break;
5384 case ISP_CONN_PTP:
5385 isp_prt(isp, ISP_LOGINFO,
5386 "Loop -> Point-to-Point mode");
5387 break;
5388 case ISP_CONN_BADLIP:
5389 isp_prt(isp, ISP_LOGWARN,
5390 "Point-to-Point -> Loop mode (BAD LIP)");
5391 break;
5392 case ISP_CONN_FATAL:
5393 isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
5394#ifdef ISP_FW_CRASH_DUMP
5395 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
5396#else
5397 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
5398 isp_reinit(isp);
5399 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
5400#endif
5401 return (-1);
5402 case ISP_CONN_LOOPBACK:
5403 isp_prt(isp, ISP_LOGWARN,
5404 "Looped Back in Point-to-Point mode");
5405 break;
5406 default:
5407 isp_prt(isp, ISP_LOGWARN,
5408 "Unknown connection mode (0x%x)", mbox);
5409 break;
5410 }
5411 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
5412 isp->isp_sendmarker = 1;
5413 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5414 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
5415 break;
5416
5417 case ASYNC_RJT_SENT: /* same as ASYNC_QFULL_SENT */
5418 if (IS_24XX(isp)) {
5419 isp_prt(isp, ISP_LOGTDEBUG0, "LS_RJT sent");
5420 break;
5421 } else if (IS_2200(isp)) {
5422 isp_prt(isp, ISP_LOGTDEBUG0, "QFULL sent");
5423 break;
5424 }
5425 /* FALLTHROUGH */
5426 default:
5427 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
5428 break;
5429 }
5430
5431 if (bus & 0x100) {
5432 int i, nh;
5433 uint16_t handles[16];
5434
5435 for (nh = 0, i = 1; i < MAX_MAILBOX(isp); i++) {
5436 if ((bus & (1 << i)) == 0) {
5437 continue;
5438 }
5439 handles[nh++] = ISP_READ(isp, MBOX_OFF(i));
5440 }
5441 for (i = 0; i < nh; i++) {
5442 isp_fastpost_complete(isp, handles[i]);
5443 isp_prt(isp, ISP_LOGDEBUG3,
5444 "fast post completion of %u", handles[i]);
5445 }
5446 if (isp->isp_fpcchiwater < nh) {
5447 isp->isp_fpcchiwater = nh;
5448 }
5449 } else {
5450 isp->isp_intoasync++;
5451 }
5452 return (rval);
5453}
5454
5455/*
5456 * Handle other response entries. A pointer to the request queue output
5457 * index is here in case we want to eat several entries at once, although
5458 * this is not used currently.
5459 */
5460
5461static int
5462isp_handle_other_response(ispsoftc_t *isp, int type,
5463 isphdr_t *hp, uint32_t *optrp)
5464{
5465 switch (type) {
5466 case RQSTYPE_STATUS_CONT:
5467 isp_prt(isp, ISP_LOGDEBUG0, "Ignored Continuation Response");
5468 return (1);
5469 case RQSTYPE_MARKER:
5470 isp_prt(isp, ISP_LOGDEBUG0, "Marker Response");
5471 return (1);
5472 case RQSTYPE_ATIO:
5473 case RQSTYPE_CTIO:
5474 case RQSTYPE_ENABLE_LUN:
5475 case RQSTYPE_MODIFY_LUN:
5476 case RQSTYPE_NOTIFY:
5477 case RQSTYPE_NOTIFY_ACK:
5478 case RQSTYPE_CTIO1:
5479 case RQSTYPE_ATIO2:
5480 case RQSTYPE_CTIO2:
5481 case RQSTYPE_CTIO3:
5482 case RQSTYPE_CTIO7:
5483 case RQSTYPE_ABTS_RCVD:
5484 case RQSTYPE_ABTS_RSP:
5485 isp->isp_rsltccmplt++; /* count as a response completion */
5486#ifdef ISP_TARGET_MODE
5487 if (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp)) {
5488 return (1);
5489 }
5490#endif
5491 /* FALLTHROUGH */
5492 case RQSTYPE_REQUEST:
5493 default:
5494 USEC_DELAY(100);
5495 if (type != isp_get_response_type(isp, hp)) {
5496 /*
5497 * This is questionable- we're just papering over
5498 * something we've seen on SMP linux in target
5499 * mode- we don't really know what's happening
5500 * here that causes us to think we've gotten
5501 * an entry, but that either the entry isn't
5502 * filled out yet or our CPU read data is stale.
5503 */
5504 isp_prt(isp, ISP_LOGINFO,
5505 "unstable type in response queue");
5506 return (-1);
5507 }
5508 isp_prt(isp, ISP_LOGWARN, "Unhandled Response Type 0x%x",
5509 isp_get_response_type(isp, hp));
5510 if (isp_async(isp, ISPASYNC_UNHANDLED_RESPONSE, hp)) {
5511 return (1);
5512 }
5513 return (0);
5514 }
5515}
5516
5517static void
5518isp_parse_status(ispsoftc_t *isp, ispstatusreq_t *sp, XS_T *xs, long *rp)
5519{
5520 switch (sp->req_completion_status & 0xff) {
5521 case RQCS_COMPLETE:
5522 if (XS_NOERR(xs)) {
5523 XS_SETERR(xs, HBA_NOERROR);
5524 }
5525 return;
5526
5527 case RQCS_INCOMPLETE:
5528 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
5529 isp_prt(isp, ISP_LOGDEBUG1,
5530 "Selection Timeout for %d.%d.%d",
5531 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5532 if (XS_NOERR(xs)) {
5533 XS_SETERR(xs, HBA_SELTIMEOUT);
5534 *rp = XS_XFRLEN(xs);
5535 }
5536 return;
5537 }
5538 isp_prt(isp, ISP_LOGERR,
5539 "command incomplete for %d.%d.%d, state 0x%x",
5540 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
5541 sp->req_state_flags);
5542 break;
5543
5544 case RQCS_DMA_ERROR:
5545 isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
5546 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5547 *rp = XS_XFRLEN(xs);
5548 break;
5549
5550 case RQCS_TRANSPORT_ERROR:
5551 {
5552 char buf[172];
5553 SNPRINTF(buf, sizeof (buf), "states=>");
5554 if (sp->req_state_flags & RQSF_GOT_BUS) {
5555 SNPRINTF(buf, sizeof (buf), "%s GOT_BUS", buf);
5556 }
5557 if (sp->req_state_flags & RQSF_GOT_TARGET) {
5558 SNPRINTF(buf, sizeof (buf), "%s GOT_TGT", buf);
5559 }
5560 if (sp->req_state_flags & RQSF_SENT_CDB) {
5561 SNPRINTF(buf, sizeof (buf), "%s SENT_CDB", buf);
5562 }
5563 if (sp->req_state_flags & RQSF_XFRD_DATA) {
5564 SNPRINTF(buf, sizeof (buf), "%s XFRD_DATA", buf);
5565 }
5566 if (sp->req_state_flags & RQSF_GOT_STATUS) {
5567 SNPRINTF(buf, sizeof (buf), "%s GOT_STS", buf);
5568 }
5569 if (sp->req_state_flags & RQSF_GOT_SENSE) {
5570 SNPRINTF(buf, sizeof (buf), "%s GOT_SNS", buf);
5571 }
5572 if (sp->req_state_flags & RQSF_XFER_COMPLETE) {
5573 SNPRINTF(buf, sizeof (buf), "%s XFR_CMPLT", buf);
5574 }
5575 SNPRINTF(buf, sizeof (buf), "%s\nstatus=>", buf);
5576 if (sp->req_status_flags & RQSTF_DISCONNECT) {
5577 SNPRINTF(buf, sizeof (buf), "%s Disconnect", buf);
5578 }
5579 if (sp->req_status_flags & RQSTF_SYNCHRONOUS) {
5580 SNPRINTF(buf, sizeof (buf), "%s Sync_xfr", buf);
5581 }
5582 if (sp->req_status_flags & RQSTF_PARITY_ERROR) {
5583 SNPRINTF(buf, sizeof (buf), "%s Parity", buf);
5584 }
5585 if (sp->req_status_flags & RQSTF_BUS_RESET) {
5586 SNPRINTF(buf, sizeof (buf), "%s Bus_Reset", buf);
5587 }
5588 if (sp->req_status_flags & RQSTF_DEVICE_RESET) {
5589 SNPRINTF(buf, sizeof (buf), "%s Device_Reset", buf);
5590 }
5591 if (sp->req_status_flags & RQSTF_ABORTED) {
5592 SNPRINTF(buf, sizeof (buf), "%s Aborted", buf);
5593 }
5594 if (sp->req_status_flags & RQSTF_TIMEOUT) {
5595 SNPRINTF(buf, sizeof (buf), "%s Timeout", buf);
5596 }
5597 if (sp->req_status_flags & RQSTF_NEGOTIATION) {
5598 SNPRINTF(buf, sizeof (buf), "%s Negotiation", buf);
5599 }
5600 isp_prt(isp, ISP_LOGERR, "%s", buf);
5601 isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d:\n%s",
5602 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), buf);
5603 *rp = XS_XFRLEN(xs);
5604 break;
5605 }
5606 case RQCS_RESET_OCCURRED:
5607 isp_prt(isp, ISP_LOGWARN,
5608 "bus reset destroyed command for %d.%d.%d",
5609 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5610 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
5611 if (XS_NOERR(xs)) {
5612 XS_SETERR(xs, HBA_BUSRESET);
5613 }
5614 *rp = XS_XFRLEN(xs);
5615 return;
5616
5617 case RQCS_ABORTED:
5618 isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d",
5619 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5620 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
5621 if (XS_NOERR(xs)) {
5622 XS_SETERR(xs, HBA_ABORTED);
5623 }
5624 return;
5625
5626 case RQCS_TIMEOUT:
5627 isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
5628 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5629 /*
5630 * XXX: Check to see if we logged out of the device.
5631 */
5632 if (XS_NOERR(xs)) {
5633 XS_SETERR(xs, HBA_CMDTIMEOUT);
5634 }
5635 return;
5636
5637 case RQCS_DATA_OVERRUN:
5638 XS_RESID(xs) = sp->req_resid;
5639 isp_prt(isp, ISP_LOGERR, "data overrun for command on %d.%d.%d",
5640 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5641 if (XS_NOERR(xs)) {
5642 XS_SETERR(xs, HBA_DATAOVR);
5643 }
5644 return;
5645
5646 case RQCS_COMMAND_OVERRUN:
5647 isp_prt(isp, ISP_LOGERR,
5648 "command overrun for command on %d.%d.%d",
5649 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5650 break;
5651
5652 case RQCS_STATUS_OVERRUN:
5653 isp_prt(isp, ISP_LOGERR,
5654 "status overrun for command on %d.%d.%d",
5655 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5656 break;
5657
5658 case RQCS_BAD_MESSAGE:
5659 isp_prt(isp, ISP_LOGERR,
5660 "msg not COMMAND COMPLETE after status %d.%d.%d",
5661 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5662 break;
5663
5664 case RQCS_NO_MESSAGE_OUT:
5665 isp_prt(isp, ISP_LOGERR,
5666 "No MESSAGE OUT phase after selection on %d.%d.%d",
5667 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5668 break;
5669
5670 case RQCS_EXT_ID_FAILED:
5671 isp_prt(isp, ISP_LOGERR, "EXTENDED IDENTIFY failed %d.%d.%d",
5672 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5673 break;
5674
5675 case RQCS_IDE_MSG_FAILED:
5676 isp_prt(isp, ISP_LOGERR,
5677 "INITIATOR DETECTED ERROR rejected by %d.%d.%d",
5678 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5679 break;
5680
5681 case RQCS_ABORT_MSG_FAILED:
5682 isp_prt(isp, ISP_LOGERR, "ABORT OPERATION rejected by %d.%d.%d",
5683 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5684 break;
5685
5686 case RQCS_REJECT_MSG_FAILED:
5687 isp_prt(isp, ISP_LOGERR, "MESSAGE REJECT rejected by %d.%d.%d",
5688 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5689 break;
5690
5691 case RQCS_NOP_MSG_FAILED:
5692 isp_prt(isp, ISP_LOGERR, "NOP rejected by %d.%d.%d",
5693 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5694 break;
5695
5696 case RQCS_PARITY_ERROR_MSG_FAILED:
5697 isp_prt(isp, ISP_LOGERR,
5698 "MESSAGE PARITY ERROR rejected by %d.%d.%d",
5699 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5700 break;
5701
5702 case RQCS_DEVICE_RESET_MSG_FAILED:
5703 isp_prt(isp, ISP_LOGWARN,
5704 "BUS DEVICE RESET rejected by %d.%d.%d",
5705 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5706 break;
5707
5708 case RQCS_ID_MSG_FAILED:
5709 isp_prt(isp, ISP_LOGERR, "IDENTIFY rejected by %d.%d.%d",
5710 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5711 break;
5712
5713 case RQCS_UNEXP_BUS_FREE:
5714 isp_prt(isp, ISP_LOGERR, "%d.%d.%d had an unexpected bus free",
5715 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5716 break;
5717
5718 case RQCS_DATA_UNDERRUN:
5719 {
5720 if (IS_FC(isp)) {
5721 int ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
5722 if (!ru_marked || sp->req_resid > XS_XFRLEN(xs)) {
5723 isp_prt(isp, ISP_LOGWARN, bun, XS_TGT(xs),
5724 XS_LUN(xs), XS_XFRLEN(xs), sp->req_resid,
5725 (ru_marked)? "marked" : "not marked");
5726 if (XS_NOERR(xs)) {
5727 XS_SETERR(xs, HBA_BOTCH);
5728 }
5729 return;
5730 }
5731 }
5732 XS_RESID(xs) = sp->req_resid;
5733 if (XS_NOERR(xs)) {
5734 XS_SETERR(xs, HBA_NOERROR);
5735 }
5736 return;
5737 }
5738
5739 case RQCS_XACT_ERR1:
5740 isp_prt(isp, ISP_LOGERR, xact1, XS_CHANNEL(xs),
5741 XS_TGT(xs), XS_LUN(xs));
5742 break;
5743
5744 case RQCS_XACT_ERR2:
5745 isp_prt(isp, ISP_LOGERR, xact2,
5746 XS_LUN(xs), XS_TGT(xs), XS_CHANNEL(xs));
5747 break;
5748
5749 case RQCS_XACT_ERR3:
5750 isp_prt(isp, ISP_LOGERR, xact3,
5751 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5752 break;
5753
5754 case RQCS_BAD_ENTRY:
5755 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
5756 break;
5757
5758 case RQCS_QUEUE_FULL:
5759 isp_prt(isp, ISP_LOGDEBUG0,
5760 "internal queues full for %d.%d.%d status 0x%x",
5761 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), *XS_STSP(xs));
5762
5763 /*
5764 * If QFULL or some other status byte is set, then this
5765 * isn't an error, per se.
5766 *
5767 * Unfortunately, some QLogic f/w writers have, in
5768 * some cases, ommitted to *set* status to QFULL.
5769 *
5770
5771 if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
5772 XS_SETERR(xs, HBA_NOERROR);
5773 return;
5774 }
5775
5776 *
5777 *
5778 */
5779
5780 *XS_STSP(xs) = SCSI_QFULL;
5781 XS_SETERR(xs, HBA_NOERROR);
5782 return;
5783
5784 case RQCS_PHASE_SKIPPED:
5785 isp_prt(isp, ISP_LOGERR, pskip, XS_CHANNEL(xs),
5786 XS_TGT(xs), XS_LUN(xs));
5787 break;
5788
5789 case RQCS_ARQS_FAILED:
5790 isp_prt(isp, ISP_LOGERR,
5791 "Auto Request Sense failed for %d.%d.%d",
5792 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5793 if (XS_NOERR(xs)) {
5794 XS_SETERR(xs, HBA_ARQFAIL);
5795 }
5796 return;
5797
5798 case RQCS_WIDE_FAILED:
5799 isp_prt(isp, ISP_LOGERR,
5800 "Wide Negotiation failed for %d.%d.%d",
5801 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
5802 if (IS_SCSI(isp)) {
5803 sdparam *sdp = isp->isp_param;
5804 sdp += XS_CHANNEL(xs);
5805 sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_WIDE;
5806 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
5807 isp->isp_update |= (1 << XS_CHANNEL(xs));
5808 }
5809 if (XS_NOERR(xs)) {
5810 XS_SETERR(xs, HBA_NOERROR);
5811 }
5812 return;
5813
5814 case RQCS_SYNCXFER_FAILED:
5815 isp_prt(isp, ISP_LOGERR,
5816 "SDTR Message failed for target %d.%d.%d",
5817 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
5818 if (IS_SCSI(isp)) {
5819 sdparam *sdp = isp->isp_param;
5820 sdp += XS_CHANNEL(xs);
5821 sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_SYNC;
5822 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
5823 isp->isp_update |= (1 << XS_CHANNEL(xs));
5824 }
5825 break;
5826
5827 case RQCS_LVD_BUSERR:
5828 isp_prt(isp, ISP_LOGERR,
5829 "Bad LVD condition while talking to %d.%d.%d",
5830 XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
5831 break;
5832
5833 case RQCS_PORT_UNAVAILABLE:
5834 /*
5835 * No such port on the loop. Moral equivalent of SELTIMEO
5836 */
5837 case RQCS_PORT_LOGGED_OUT:
5838 {
5839 char *reason;
5840 uint8_t sts = sp->req_completion_status & 0xff;
5841
5842 /*
5843 * It was there (maybe)- treat as a selection timeout.
5844 */
5845 if (sts == RQCS_PORT_UNAVAILABLE) {
5846 reason = "unavailable";
5847 } else {
5848 reason = "logout";
5849 }
5850
5851 isp_prt(isp, ISP_LOGINFO, "port %s for target %d",
5852 reason, XS_TGT(xs));
5853
5854 /*
5855 * If we're on a local loop, force a LIP (which is overkill)
5856 * to force a re-login of this unit. If we're on fabric,
5857 * then we'll have to log in again as a matter of course.
5858 */
5859 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
5860 FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
5861 mbreg_t mbs;
5862 MEMZERO(&mbs, sizeof (mbs));
5863 mbs.param[0] = MBOX_INIT_LIP;
5864 if (FCPARAM(isp)->isp_2klogin) {
5865 mbs.ibits = (1 << 10);
5866 }
5867 mbs.logval = MBLOGALL;
5868 isp_mboxcmd_qnw(isp, &mbs, 1);
5869 }
5870 if (XS_NOERR(xs)) {
5871 XS_SETERR(xs, HBA_SELTIMEOUT);
5872 }
5873 return;
5874 }
5875 case RQCS_PORT_CHANGED:
5876 isp_prt(isp, ISP_LOGWARN,
5877 "port changed for target %d", XS_TGT(xs));
5878 if (XS_NOERR(xs)) {
5879 XS_SETERR(xs, HBA_SELTIMEOUT);
5880 }
5881 return;
5882
5883 case RQCS_PORT_BUSY:
5884 isp_prt(isp, ISP_LOGWARN,
5885 "port busy for target %d", XS_TGT(xs));
5886 if (XS_NOERR(xs)) {
5887 XS_SETERR(xs, HBA_TGTBSY);
5888 }
5889 return;
5890
5891 default:
5892 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
5893 sp->req_completion_status);
5894 break;
5895 }
5896 if (XS_NOERR(xs)) {
5897 XS_SETERR(xs, HBA_BOTCH);
5898 }
5899}
5900
5901static void
5902isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp,
5903 XS_T *xs, long *rp)
5904{
5905 switch (sp->req_completion_status) {
5906 case RQCS_COMPLETE:
5907 if (XS_NOERR(xs)) {
5908 XS_SETERR(xs, HBA_NOERROR);
5909 }
5910 return;
5911
5912 case RQCS_DMA_ERROR:
5913 isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
5914 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5915 break;
5916
5917 case RQCS_TRANSPORT_ERROR:
5918 isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d",
5919 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5920 break;
5921
5922 case RQCS_RESET_OCCURRED:
5923 isp_prt(isp, ISP_LOGWARN,
5924 "bus reset destroyed command for %d.%d.%d",
5925 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5926 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
5927 if (XS_NOERR(xs)) {
5928 XS_SETERR(xs, HBA_BUSRESET);
5929 }
5930 return;
5931
5932 case RQCS_ABORTED:
5933 isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d",
5934 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5935 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
5936 if (XS_NOERR(xs)) {
5937 XS_SETERR(xs, HBA_ABORTED);
5938 }
5939 return;
5940
5941 case RQCS_TIMEOUT:
5942 isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
5943 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5944 if (XS_NOERR(xs)) {
5945 XS_SETERR(xs, HBA_CMDTIMEOUT);
5946 }
5947 return;
5948
5949 case RQCS_DATA_OVERRUN:
5950 XS_RESID(xs) = sp->req_resid;
5951 isp_prt(isp, ISP_LOGERR, "data overrun for command on %d.%d.%d",
5952 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5953 if (XS_NOERR(xs)) {
5954 XS_SETERR(xs, HBA_DATAOVR);
5955 }
5956 return;
5957
5958 case RQCS_24XX_DRE: /* data reassembly error */
5959 isp_prt(isp, ISP_LOGERR, "data reassembly error for target %d",
5960 XS_TGT(xs));
5961 if (XS_NOERR(xs)) {
5962 XS_SETERR(xs, HBA_ABORTED);
5963 }
5964 *rp = XS_XFRLEN(xs);
5965 return;
5966
5967 case RQCS_24XX_TABORT: /* aborted by target */
5968 isp_prt(isp, ISP_LOGERR, "target %d sent ABTS",
5969 XS_TGT(xs));
5970 if (XS_NOERR(xs)) {
5971 XS_SETERR(xs, HBA_ABORTED);
5972 }
5973 return;
5974
5975 case RQCS_DATA_UNDERRUN:
5976
5977 XS_RESID(xs) = sp->req_resid;
5978 if (XS_NOERR(xs)) {
5979 XS_SETERR(xs, HBA_NOERROR);
5980 }
5981 return;
5982
5983 case RQCS_PORT_UNAVAILABLE:
5984 /*
5985 * No such port on the loop. Moral equivalent of SELTIMEO
5986 */
5987 case RQCS_PORT_LOGGED_OUT:
5988 {
5989 char *reason;
5990 uint8_t sts = sp->req_completion_status & 0xff;
5991
5992 /*
5993 * It was there (maybe)- treat as a selection timeout.
5994 */
5995 if (sts == RQCS_PORT_UNAVAILABLE) {
5996 reason = "unavailable";
5997 } else {
5998 reason = "logout";
5999 }
6000
6001 isp_prt(isp, ISP_LOGINFO, "port %s for target %d",
6002 reason, XS_TGT(xs));
6003
6004 /*
6005 * If we're on a local loop, force a LIP (which is overkill)
6006 * to force a re-login of this unit. If we're on fabric,
6007 * then we'll have to log in again as a matter of course.
6008 */
6009 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
6010 FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
6011 mbreg_t mbs;
6012 MEMZERO(&mbs, sizeof (mbs));
6013 mbs.param[0] = MBOX_INIT_LIP;
6014 if (FCPARAM(isp)->isp_2klogin) {
6015 mbs.ibits = (1 << 10);
6016 }
6017 mbs.logval = MBLOGALL;
6018 isp_mboxcmd_qnw(isp, &mbs, 1);
6019 }
6020 if (XS_NOERR(xs)) {
6021 XS_SETERR(xs, HBA_SELTIMEOUT);
6022 }
6023 return;
6024 }
6025 case RQCS_PORT_CHANGED:
6026 isp_prt(isp, ISP_LOGWARN,
6027 "port changed for target %d", XS_TGT(xs));
6028 if (XS_NOERR(xs)) {
6029 XS_SETERR(xs, HBA_SELTIMEOUT);
6030 }
6031 return;
6032
6033
6034 case RQCS_24XX_ENOMEM: /* f/w resource unavailable */
6035 isp_prt(isp, ISP_LOGWARN,
6036 "f/w resource unavailable for target %d", XS_TGT(xs));
6037 if (XS_NOERR(xs)) {
6038 *XS_STSP(xs) = SCSI_BUSY;
6039 XS_SETERR(xs, HBA_TGTBSY);
6040 }
6041 return;
6042
6043 case RQCS_24XX_TMO: /* task management overrun */
6044 isp_prt(isp, ISP_LOGWARN,
6045 "command for target %d overlapped task management",
6046 XS_TGT(xs));
6047 if (XS_NOERR(xs)) {
6048 *XS_STSP(xs) = SCSI_BUSY;
6049 XS_SETERR(xs, HBA_TGTBSY);
6050 }
6051 return;
6052
6053 default:
6054 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
6055 sp->req_completion_status);
6056 break;
6057 }
6058 if (XS_NOERR(xs)) {
6059 XS_SETERR(xs, HBA_BOTCH);
6060 }
6061}
6062
6063static void
6064isp_fastpost_complete(ispsoftc_t *isp, uint16_t fph)
6065{
6066 XS_T *xs;
6067
6068 if (fph == 0) {
6069 return;
6070 }
6071 xs = isp_find_xs(isp, fph);
6072 if (xs == NULL) {
6073 isp_prt(isp, ISP_LOGWARN,
6074 "Command for fast post handle 0x%x not found", fph);
6075 return;
6076 }
6077 isp_destroy_handle(isp, fph);
6078
6079 /*
6080 * Since we don't have a result queue entry item,
6081 * we must believe that SCSI status is zero and
6082 * that all data transferred.
6083 */
6084 XS_SET_STATE_STAT(isp, xs, NULL);
6085 XS_RESID(xs) = 0;
6086 *XS_STSP(xs) = SCSI_GOOD;
6087 if (XS_XFRLEN(xs)) {
6088 ISP_DMAFREE(isp, xs, fph);
6089 }
6090 if (isp->isp_nactive)
6091 isp->isp_nactive--;
6092 isp->isp_fphccmplt++;
6093 isp_done(xs);
6094}
6095
6096static int
6097isp_mbox_continue(ispsoftc_t *isp)
6098{
6099 mbreg_t mbs;
6100 uint16_t *ptr;
6101 uint32_t offset;
6102
6103 switch (isp->isp_lastmbxcmd) {
6104 case MBOX_WRITE_RAM_WORD:
6105 case MBOX_READ_RAM_WORD:
6106 case MBOX_WRITE_RAM_WORD_EXTENDED:
6107 case MBOX_READ_RAM_WORD_EXTENDED:
6108 break;
6109 default:
6110 return (1);
6111 }
6112 if (isp->isp_mboxtmp[0] != MBOX_COMMAND_COMPLETE) {
6113 isp->isp_mbxwrk0 = 0;
6114 return (-1);
6115 }
6116
6117 /*
6118 * Clear the previous interrupt.
6119 */
6120 if (IS_24XX(isp)) {
6121 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
6122 } else {
6123 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
6124 ISP_WRITE(isp, BIU_SEMA, 0);
6125 }
6126
6127 /*
6128 * Continue with next word.
6129 */
6130 MEMZERO(&mbs, sizeof (mbs));
6131 ptr = isp->isp_mbxworkp;
6132 switch (isp->isp_lastmbxcmd) {
6133 case MBOX_WRITE_RAM_WORD:
6134 mbs.param[1] = isp->isp_mbxwrk1++;;
6135 mbs.param[2] = *ptr++;;
6136 break;
6137 case MBOX_READ_RAM_WORD:
6138 *ptr++ = isp->isp_mboxtmp[2];
6139 mbs.param[1] = isp->isp_mbxwrk1++;
6140 break;
6141 case MBOX_WRITE_RAM_WORD_EXTENDED:
6142 offset = isp->isp_mbxwrk1;
6143 offset |= isp->isp_mbxwrk8 << 16;
6144
6145 mbs.param[2] = *ptr++;;
6146 mbs.param[1] = offset;
6147 mbs.param[8] = offset >> 16;
6148 isp->isp_mbxwrk1 = ++offset;
6149 isp->isp_mbxwrk8 = offset >> 16;
6150 break;
6151 case MBOX_READ_RAM_WORD_EXTENDED:
6152 offset = isp->isp_mbxwrk1;
6153 offset |= isp->isp_mbxwrk8 << 16;
6154
6155 *ptr++ = isp->isp_mboxtmp[2];
6156 mbs.param[1] = offset;
6157 mbs.param[8] = offset >> 16;
6158 isp->isp_mbxwrk1 = ++offset;
6159 isp->isp_mbxwrk8 = offset >> 16;
6160 break;
6161 }
6162 isp->isp_mbxworkp = ptr;
6163 isp->isp_mbxwrk0--;
6164 mbs.param[0] = isp->isp_lastmbxcmd;
6165 mbs.logval = MBLOGALL;
6166 isp_mboxcmd_qnw(isp, &mbs, 0);
6167 return (0);
6168}
6169
6170#define HIWRD(x) ((x) >> 16)
6171#define LOWRD(x) ((x) & 0xffff)
6172#define ISPOPMAP(a, b) (((a) << 16) | (b))
6173static const uint32_t mbpscsi[] = {
6174 ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
6175 ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
6176 ISPOPMAP(0x03, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */
6177 ISPOPMAP(0x1f, 0x01), /* 0x03: MBOX_DUMP_RAM */
6178 ISPOPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
6179 ISPOPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
6180 ISPOPMAP(0x3f, 0x3f), /* 0x06: MBOX_MAILBOX_REG_TEST */
6181 ISPOPMAP(0x07, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */
6182 ISPOPMAP(0x01, 0x0f), /* 0x08: MBOX_ABOUT_FIRMWARE */
6183 ISPOPMAP(0x00, 0x00), /* 0x09: */
6184 ISPOPMAP(0x00, 0x00), /* 0x0a: */
6185 ISPOPMAP(0x00, 0x00), /* 0x0b: */
6186 ISPOPMAP(0x00, 0x00), /* 0x0c: */
6187 ISPOPMAP(0x00, 0x00), /* 0x0d: */
6188 ISPOPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
6189 ISPOPMAP(0x00, 0x00), /* 0x0f: */
6190 ISPOPMAP(0x1f, 0x1f), /* 0x10: MBOX_INIT_REQ_QUEUE */
6191 ISPOPMAP(0x3f, 0x3f), /* 0x11: MBOX_INIT_RES_QUEUE */
6192 ISPOPMAP(0x0f, 0x0f), /* 0x12: MBOX_EXECUTE_IOCB */
6193 ISPOPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */
6194 ISPOPMAP(0x01, 0x3f), /* 0x14: MBOX_STOP_FIRMWARE */
6195 ISPOPMAP(0x0f, 0x0f), /* 0x15: MBOX_ABORT */
6196 ISPOPMAP(0x03, 0x03), /* 0x16: MBOX_ABORT_DEVICE */
6197 ISPOPMAP(0x07, 0x07), /* 0x17: MBOX_ABORT_TARGET */
6198 ISPOPMAP(0x07, 0x07), /* 0x18: MBOX_BUS_RESET */
6199 ISPOPMAP(0x03, 0x07), /* 0x19: MBOX_STOP_QUEUE */
6200 ISPOPMAP(0x03, 0x07), /* 0x1a: MBOX_START_QUEUE */
6201 ISPOPMAP(0x03, 0x07), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6202 ISPOPMAP(0x03, 0x07), /* 0x1c: MBOX_ABORT_QUEUE */
6203 ISPOPMAP(0x03, 0x4f), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6204 ISPOPMAP(0x00, 0x00), /* 0x1e: */
6205 ISPOPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6206 ISPOPMAP(0x01, 0x07), /* 0x20: MBOX_GET_INIT_SCSI_ID */
6207 ISPOPMAP(0x01, 0x07), /* 0x21: MBOX_GET_SELECT_TIMEOUT */
6208 ISPOPMAP(0x01, 0xc7), /* 0x22: MBOX_GET_RETRY_COUNT */
6209 ISPOPMAP(0x01, 0x07), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
6210 ISPOPMAP(0x01, 0x03), /* 0x24: MBOX_GET_CLOCK_RATE */
6211 ISPOPMAP(0x01, 0x07), /* 0x25: MBOX_GET_ACT_NEG_STATE */
6212 ISPOPMAP(0x01, 0x07), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
6213 ISPOPMAP(0x01, 0x07), /* 0x27: MBOX_GET_PCI_PARAMS */
6214 ISPOPMAP(0x03, 0x4f), /* 0x28: MBOX_GET_TARGET_PARAMS */
6215 ISPOPMAP(0x03, 0x0f), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
6216 ISPOPMAP(0x01, 0x07), /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */
6217 ISPOPMAP(0x00, 0x00), /* 0x2b: */
6218 ISPOPMAP(0x00, 0x00), /* 0x2c: */
6219 ISPOPMAP(0x00, 0x00), /* 0x2d: */
6220 ISPOPMAP(0x00, 0x00), /* 0x2e: */
6221 ISPOPMAP(0x00, 0x00), /* 0x2f: */
6222 ISPOPMAP(0x03, 0x03), /* 0x30: MBOX_SET_INIT_SCSI_ID */
6223 ISPOPMAP(0x07, 0x07), /* 0x31: MBOX_SET_SELECT_TIMEOUT */
6224 ISPOPMAP(0xc7, 0xc7), /* 0x32: MBOX_SET_RETRY_COUNT */
6225 ISPOPMAP(0x07, 0x07), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
6226 ISPOPMAP(0x03, 0x03), /* 0x34: MBOX_SET_CLOCK_RATE */
6227 ISPOPMAP(0x07, 0x07), /* 0x35: MBOX_SET_ACT_NEG_STATE */
6228 ISPOPMAP(0x07, 0x07), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
6229 ISPOPMAP(0x07, 0x07), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
6230 ISPOPMAP(0x4f, 0x4f), /* 0x38: MBOX_SET_TARGET_PARAMS */
6231 ISPOPMAP(0x0f, 0x0f), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
6232 ISPOPMAP(0x07, 0x07), /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */
6233 ISPOPMAP(0x00, 0x00), /* 0x3b: */
6234 ISPOPMAP(0x00, 0x00), /* 0x3c: */
6235 ISPOPMAP(0x00, 0x00), /* 0x3d: */
6236 ISPOPMAP(0x00, 0x00), /* 0x3e: */
6237 ISPOPMAP(0x00, 0x00), /* 0x3f: */
6238 ISPOPMAP(0x01, 0x03), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
6239 ISPOPMAP(0x3f, 0x01), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
6240 ISPOPMAP(0x03, 0x07), /* 0x42: MBOX_EXEC_BIOS_IOCB */
6241 ISPOPMAP(0x00, 0x00), /* 0x43: */
6242 ISPOPMAP(0x00, 0x00), /* 0x44: */
6243 ISPOPMAP(0x03, 0x03), /* 0x45: SET SYSTEM PARAMETER */
6244 ISPOPMAP(0x01, 0x03), /* 0x46: GET SYSTEM PARAMETER */
6245 ISPOPMAP(0x00, 0x00), /* 0x47: */
6246 ISPOPMAP(0x01, 0xcf), /* 0x48: GET SCAM CONFIGURATION */
6247 ISPOPMAP(0xcf, 0xcf), /* 0x49: SET SCAM CONFIGURATION */
6248 ISPOPMAP(0x03, 0x03), /* 0x4a: MBOX_SET_FIRMWARE_FEATURES */
6249 ISPOPMAP(0x01, 0x03), /* 0x4b: MBOX_GET_FIRMWARE_FEATURES */
6250 ISPOPMAP(0x00, 0x00), /* 0x4c: */
6251 ISPOPMAP(0x00, 0x00), /* 0x4d: */
6252 ISPOPMAP(0x00, 0x00), /* 0x4e: */
6253 ISPOPMAP(0x00, 0x00), /* 0x4f: */
6254 ISPOPMAP(0xdf, 0xdf), /* 0x50: LOAD RAM A64 */
6255 ISPOPMAP(0xdf, 0xdf), /* 0x51: DUMP RAM A64 */
6256 ISPOPMAP(0xdf, 0xff), /* 0x52: INITIALIZE REQUEST QUEUE A64 */
6257 ISPOPMAP(0xef, 0xff), /* 0x53: INITIALIZE RESPONSE QUEUE A64 */
6258 ISPOPMAP(0xcf, 0x01), /* 0x54: EXECUCUTE COMMAND IOCB A64 */
6259 ISPOPMAP(0x07, 0x01), /* 0x55: ENABLE TARGET MODE */
6260 ISPOPMAP(0x03, 0x0f), /* 0x56: GET TARGET STATUS */
6261 ISPOPMAP(0x00, 0x00), /* 0x57: */
6262 ISPOPMAP(0x00, 0x00), /* 0x58: */
6263 ISPOPMAP(0x00, 0x00), /* 0x59: */
6264 ISPOPMAP(0x03, 0x03), /* 0x5a: SET DATA OVERRUN RECOVERY MODE */
6265 ISPOPMAP(0x01, 0x03), /* 0x5b: GET DATA OVERRUN RECOVERY MODE */
6266 ISPOPMAP(0x0f, 0x0f), /* 0x5c: SET HOST DATA */
6267 ISPOPMAP(0x01, 0x01) /* 0x5d: GET NOST DATA */
6268};
6269
6270static char *scsi_mbcmd_names[] = {
6271 "NO-OP",
6272 "LOAD RAM",
6273 "EXEC FIRMWARE",
6274 "DUMP RAM",
6275 "WRITE RAM WORD",
6276 "READ RAM WORD",
6277 "MAILBOX REG TEST",
6278 "VERIFY CHECKSUM",
6279 "ABOUT FIRMWARE",
6280 NULL,
6281 NULL,
6282 NULL,
6283 NULL,
6284 NULL,
6285 "CHECK FIRMWARE",
6286 NULL,
6287 "INIT REQUEST QUEUE",
6288 "INIT RESULT QUEUE",
6289 "EXECUTE IOCB",
6290 "WAKE UP",
6291 "STOP FIRMWARE",
6292 "ABORT",
6293 "ABORT DEVICE",
6294 "ABORT TARGET",
6295 "BUS RESET",
6296 "STOP QUEUE",
6297 "START QUEUE",
6298 "SINGLE STEP QUEUE",
6299 "ABORT QUEUE",
6300 "GET DEV QUEUE STATUS",
6301 NULL,
6302 "GET FIRMWARE STATUS",
6303 "GET INIT SCSI ID",
6304 "GET SELECT TIMEOUT",
6305 "GET RETRY COUNT",
6306 "GET TAG AGE LIMIT",
6307 "GET CLOCK RATE",
6308 "GET ACT NEG STATE",
6309 "GET ASYNC DATA SETUP TIME",
6310 "GET PCI PARAMS",
6311 "GET TARGET PARAMS",
6312 "GET DEV QUEUE PARAMS",
6313 "GET RESET DELAY PARAMS",
6314 NULL,
6315 NULL,
6316 NULL,
6317 NULL,
6318 NULL,
6319 "SET INIT SCSI ID",
6320 "SET SELECT TIMEOUT",
6321 "SET RETRY COUNT",
6322 "SET TAG AGE LIMIT",
6323 "SET CLOCK RATE",
6324 "SET ACT NEG STATE",
6325 "SET ASYNC DATA SETUP TIME",
6326 "SET PCI CONTROL PARAMS",
6327 "SET TARGET PARAMS",
6328 "SET DEV QUEUE PARAMS",
6329 "SET RESET DELAY PARAMS",
6330 NULL,
6331 NULL,
6332 NULL,
6333 NULL,
6334 NULL,
6335 "RETURN BIOS BLOCK ADDR",
6336 "WRITE FOUR RAM WORDS",
6337 "EXEC BIOS IOCB",
6338 NULL,
6339 NULL,
6340 "SET SYSTEM PARAMETER",
6341 "GET SYSTEM PARAMETER",
6342 NULL,
6343 "GET SCAM CONFIGURATION",
6344 "SET SCAM CONFIGURATION",
6345 "SET FIRMWARE FEATURES",
6346 "GET FIRMWARE FEATURES",
6347 NULL,
6348 NULL,
6349 NULL,
6350 NULL,
6351 "LOAD RAM A64",
6352 "DUMP RAM A64",
6353 "INITIALIZE REQUEST QUEUE A64",
6354 "INITIALIZE RESPONSE QUEUE A64",
6355 "EXECUTE IOCB A64",
6356 "ENABLE TARGET MODE",
6357 "GET TARGET MODE STATE",
6358 NULL,
6359 NULL,
6360 NULL,
6361 "SET DATA OVERRUN RECOVERY MODE",
6362 "GET DATA OVERRUN RECOVERY MODE",
6363 "SET HOST DATA",
6364 "GET NOST DATA",
6365};
6366
6367static const uint32_t mbpfc[] = {
6368 ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
6369 ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
6370 ISPOPMAP(0x0f, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */
6371 ISPOPMAP(0xdf, 0x01), /* 0x03: MBOX_DUMP_RAM */
6372 ISPOPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
6373 ISPOPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
6374 ISPOPMAP(0xff, 0xff), /* 0x06: MBOX_MAILBOX_REG_TEST */
6375 ISPOPMAP(0x03, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */
6376 ISPOPMAP(0x01, 0x4f), /* 0x08: MBOX_ABOUT_FIRMWARE */
6377 ISPOPMAP(0xdf, 0x01), /* 0x09: MBOX_LOAD_RISC_RAM_2100 */
6378 ISPOPMAP(0xdf, 0x01), /* 0x0a: DUMP RAM */
6379 ISPOPMAP(0x1ff, 0x01), /* 0x0b: MBOX_LOAD_RISC_RAM */
6380 ISPOPMAP(0x00, 0x00), /* 0x0c: */
6381 ISPOPMAP(0x10f, 0x01), /* 0x0d: MBOX_WRITE_RAM_WORD_EXTENDED */
6382 ISPOPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
6383 ISPOPMAP(0x10f, 0x05), /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED */
6384 ISPOPMAP(0x1f, 0x11), /* 0x10: MBOX_INIT_REQ_QUEUE */
6385 ISPOPMAP(0x2f, 0x21), /* 0x11: MBOX_INIT_RES_QUEUE */
6386 ISPOPMAP(0x0f, 0x01), /* 0x12: MBOX_EXECUTE_IOCB */
6387 ISPOPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */
6388 ISPOPMAP(0x01, 0xff), /* 0x14: MBOX_STOP_FIRMWARE */
6389 ISPOPMAP(0x4f, 0x01), /* 0x15: MBOX_ABORT */
6390 ISPOPMAP(0x07, 0x01), /* 0x16: MBOX_ABORT_DEVICE */
6391 ISPOPMAP(0x07, 0x01), /* 0x17: MBOX_ABORT_TARGET */
6392 ISPOPMAP(0x03, 0x03), /* 0x18: MBOX_BUS_RESET */
6393 ISPOPMAP(0x07, 0x05), /* 0x19: MBOX_STOP_QUEUE */
6394 ISPOPMAP(0x07, 0x05), /* 0x1a: MBOX_START_QUEUE */
6395 ISPOPMAP(0x07, 0x05), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6396 ISPOPMAP(0x07, 0x05), /* 0x1c: MBOX_ABORT_QUEUE */
6397 ISPOPMAP(0x07, 0x03), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6398 ISPOPMAP(0x00, 0x00), /* 0x1e: */
6399 ISPOPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6400 ISPOPMAP(0x01, 0x4f), /* 0x20: MBOX_GET_LOOP_ID */
6401 ISPOPMAP(0x00, 0x00), /* 0x21: */
6402 ISPOPMAP(0x01, 0x07), /* 0x22: MBOX_GET_RETRY_COUNT */
6403 ISPOPMAP(0x00, 0x00), /* 0x23: */
6404 ISPOPMAP(0x00, 0x00), /* 0x24: */
6405 ISPOPMAP(0x00, 0x00), /* 0x25: */
6406 ISPOPMAP(0x00, 0x00), /* 0x26: */
6407 ISPOPMAP(0x00, 0x00), /* 0x27: */
6408 ISPOPMAP(0x01, 0x03), /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */
6409 ISPOPMAP(0x03, 0x07), /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */
6410 ISPOPMAP(0x00, 0x00), /* 0x2a: */
6411 ISPOPMAP(0x00, 0x00), /* 0x2b: */
6412 ISPOPMAP(0x00, 0x00), /* 0x2c: */
6413 ISPOPMAP(0x00, 0x00), /* 0x2d: */
6414 ISPOPMAP(0x00, 0x00), /* 0x2e: */
6415 ISPOPMAP(0x00, 0x00), /* 0x2f: */
6416 ISPOPMAP(0x00, 0x00), /* 0x30: */
6417 ISPOPMAP(0x00, 0x00), /* 0x31: */
6418 ISPOPMAP(0x07, 0x07), /* 0x32: MBOX_SET_RETRY_COUNT */
6419 ISPOPMAP(0x00, 0x00), /* 0x33: */
6420 ISPOPMAP(0x00, 0x00), /* 0x34: */
6421 ISPOPMAP(0x00, 0x00), /* 0x35: */
6422 ISPOPMAP(0x00, 0x00), /* 0x36: */
6423 ISPOPMAP(0x00, 0x00), /* 0x37: */
6424 ISPOPMAP(0x0f, 0x01), /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */
6425 ISPOPMAP(0x0f, 0x07), /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */
6426 ISPOPMAP(0x00, 0x00), /* 0x3a: */
6427 ISPOPMAP(0x00, 0x00), /* 0x3b: */
6428 ISPOPMAP(0x00, 0x00), /* 0x3c: */
6429 ISPOPMAP(0x00, 0x00), /* 0x3d: */
6430 ISPOPMAP(0x00, 0x00), /* 0x3e: */
6431 ISPOPMAP(0x00, 0x00), /* 0x3f: */
6432 ISPOPMAP(0x03, 0x01), /* 0x40: MBOX_LOOP_PORT_BYPASS */
6433 ISPOPMAP(0x03, 0x01), /* 0x41: MBOX_LOOP_PORT_ENABLE */
6434 ISPOPMAP(0x03, 0x07), /* 0x42: MBOX_GET_RESOURCE_COUNT */
6435 ISPOPMAP(0x01, 0x01), /* 0x43: MBOX_REQUEST_OFFLINE_MODE */
6436 ISPOPMAP(0x00, 0x00), /* 0x44: */
6437 ISPOPMAP(0x00, 0x00), /* 0x45: */
6438 ISPOPMAP(0x00, 0x00), /* 0x46: */
6439 ISPOPMAP(0xcf, 0x03), /* 0x47: GET PORT_DATABASE ENHANCED */
6440 ISPOPMAP(0x00, 0x00), /* 0x48: */
6441 ISPOPMAP(0x00, 0x00), /* 0x49: */
6442 ISPOPMAP(0x00, 0x00), /* 0x4a: */
6443 ISPOPMAP(0x00, 0x00), /* 0x4b: */
6444 ISPOPMAP(0x00, 0x00), /* 0x4c: */
6445 ISPOPMAP(0x00, 0x00), /* 0x4d: */
6446 ISPOPMAP(0x00, 0x00), /* 0x4e: */
6447 ISPOPMAP(0x00, 0x00), /* 0x4f: */
6448 ISPOPMAP(0x00, 0x00), /* 0x50: */
6449 ISPOPMAP(0x00, 0x00), /* 0x51: */
6450 ISPOPMAP(0x00, 0x00), /* 0x52: */
6451 ISPOPMAP(0x00, 0x00), /* 0x53: */
6452 ISPOPMAP(0xcf, 0x01), /* 0x54: EXECUTE IOCB A64 */
6453 ISPOPMAP(0x00, 0x00), /* 0x55: */
6454 ISPOPMAP(0x00, 0x00), /* 0x56: */
6455 ISPOPMAP(0x00, 0x00), /* 0x57: */
6456 ISPOPMAP(0x00, 0x00), /* 0x58: */
6457 ISPOPMAP(0x00, 0x00), /* 0x59: */
6458 ISPOPMAP(0x00, 0x00), /* 0x5a: */
6459 ISPOPMAP(0x03, 0x01), /* 0x5b: MBOX_DRIVER_HEARTBEAT */
6460 ISPOPMAP(0xcf, 0x01), /* 0x5c: MBOX_FW_HEARTBEAT */
6461 ISPOPMAP(0x07, 0x03), /* 0x5d: MBOX_GET_SET_DATA_RATE */
6462 ISPOPMAP(0x00, 0x00), /* 0x5e: */
6463 ISPOPMAP(0x00, 0x00), /* 0x5f: */
6464 ISPOPMAP(0xcd, 0x01), /* 0x60: MBOX_INIT_FIRMWARE */
6465 ISPOPMAP(0x00, 0x00), /* 0x61: */
6466 ISPOPMAP(0x01, 0x01), /* 0x62: MBOX_INIT_LIP */
6467 ISPOPMAP(0xcd, 0x03), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
6468 ISPOPMAP(0xcf, 0x01), /* 0x64: MBOX_GET_PORT_DB */
6469 ISPOPMAP(0x07, 0x01), /* 0x65: MBOX_CLEAR_ACA */
6470 ISPOPMAP(0x07, 0x01), /* 0x66: MBOX_TARGET_RESET */
6471 ISPOPMAP(0x07, 0x01), /* 0x67: MBOX_CLEAR_TASK_SET */
6472 ISPOPMAP(0x07, 0x01), /* 0x68: MBOX_ABORT_TASK_SET */
6473 ISPOPMAP(0x01, 0x07), /* 0x69: MBOX_GET_FW_STATE */
6474 ISPOPMAP(0x03, 0xcf), /* 0x6a: MBOX_GET_PORT_NAME */
6475 ISPOPMAP(0xcf, 0x01), /* 0x6b: MBOX_GET_LINK_STATUS */
6476 ISPOPMAP(0x0f, 0x01), /* 0x6c: MBOX_INIT_LIP_RESET */
6477 ISPOPMAP(0x00, 0x00), /* 0x6d: */
6478 ISPOPMAP(0xcf, 0x03), /* 0x6e: MBOX_SEND_SNS */
6479 ISPOPMAP(0x0f, 0x07), /* 0x6f: MBOX_FABRIC_LOGIN */
6480 ISPOPMAP(0x03, 0x01), /* 0x70: MBOX_SEND_CHANGE_REQUEST */
6481 ISPOPMAP(0x03, 0x03), /* 0x71: MBOX_FABRIC_LOGOUT */
6482 ISPOPMAP(0x0f, 0x0f), /* 0x72: MBOX_INIT_LIP_LOGIN */
6483 ISPOPMAP(0x00, 0x00), /* 0x73: */
6484 ISPOPMAP(0x07, 0x01), /* 0x74: LOGIN LOOP PORT */
6485 ISPOPMAP(0xcf, 0x03), /* 0x75: GET PORT/NODE NAME LIST */
6486 ISPOPMAP(0x4f, 0x01), /* 0x76: SET VENDOR ID */
6487 ISPOPMAP(0xcd, 0x01), /* 0x77: INITIALIZE IP MAILBOX */
6488 ISPOPMAP(0x00, 0x00), /* 0x78: */
6489 ISPOPMAP(0x00, 0x00), /* 0x79: */
6490 ISPOPMAP(0x00, 0x00), /* 0x7a: */
6491 ISPOPMAP(0x00, 0x00), /* 0x7b: */
6492 ISPOPMAP(0x4f, 0x03), /* 0x7c: Get ID List */
6493 ISPOPMAP(0xcf, 0x01), /* 0x7d: SEND LFA */
6494 ISPOPMAP(0x0f, 0x01) /* 0x7e: LUN RESET */
6495};
6496/*
6497 * Footnotes
6498 *
6499 * (1): this sets bits 21..16 in mailbox register #8, which we nominally
6500 * do not access at this time in the core driver. The caller is
6501 * responsible for setting this register first (Gross!). The assumption
6502 * is that we won't overflow.
6503 */
6504
6505static char *fc_mbcmd_names[] = {
6506 "NO-OP",
6507 "LOAD RAM",
6508 "EXEC FIRMWARE",
6509 "DUMP RAM",
6510 "WRITE RAM WORD",
6511 "READ RAM WORD",
6512 "MAILBOX REG TEST",
6513 "VERIFY CHECKSUM",
6514 "ABOUT FIRMWARE",
6515 "LOAD RAM",
6516 "DUMP RAM",
6517 "WRITE RAM WORD EXTENDED",
6518 NULL,
6519 "READ RAM WORD EXTENDED",
6520 "CHECK FIRMWARE",
6521 NULL,
6522 "INIT REQUEST QUEUE",
6523 "INIT RESULT QUEUE",
6524 "EXECUTE IOCB",
6525 "WAKE UP",
6526 "STOP FIRMWARE",
6527 "ABORT",
6528 "ABORT DEVICE",
6529 "ABORT TARGET",
6530 "BUS RESET",
6531 "STOP QUEUE",
6532 "START QUEUE",
6533 "SINGLE STEP QUEUE",
6534 "ABORT QUEUE",
6535 "GET DEV QUEUE STATUS",
6536 NULL,
6537 "GET FIRMWARE STATUS",
6538 "GET LOOP ID",
6539 NULL,
6540 "GET RETRY COUNT",
6541 NULL,
6542 NULL,
6543 NULL,
6544 NULL,
6545 NULL,
6546 "GET FIRMWARE OPTIONS",
6547 "GET PORT QUEUE PARAMS",
6548 NULL,
6549 NULL,
6550 NULL,
6551 NULL,
6552 NULL,
6553 NULL,
6554 NULL,
6555 NULL,
6556 "SET RETRY COUNT",
6557 NULL,
6558 NULL,
6559 NULL,
6560 NULL,
6561 NULL,
6562 "SET FIRMWARE OPTIONS",
6563 "SET PORT QUEUE PARAMS",
6564 NULL,
6565 NULL,
6566 NULL,
6567 NULL,
6568 NULL,
6569 NULL,
6570 "LOOP PORT BYPASS",
6571 "LOOP PORT ENABLE",
6572 "GET RESOURCE COUNT",
6573 "REQUEST NON PARTICIPATING MODE",
6574 NULL,
6575 NULL,
6576 NULL,
6577 "GET PORT DATABASE ENHANCED",
6578 NULL,
6579 NULL,
6580 NULL,
6581 NULL,
6582 NULL,
6583 NULL,
6584 NULL,
6585 NULL,
6586 NULL,
6587 NULL,
6588 NULL,
6589 NULL,
6590 "EXECUTE IOCB A64",
6591 NULL,
6592 NULL,
6593 NULL,
6594 NULL,
6595 NULL,
6596 NULL,
6597 "DRIVER HEARTBEAT",
6598 NULL,
6599 "GET/SET DATA RATE",
6600 NULL,
6601 NULL,
6602 "INIT FIRMWARE",
6603 NULL,
6604 "INIT LIP",
6605 "GET FC-AL POSITION MAP",
6606 "GET PORT DATABASE",
6607 "CLEAR ACA",
6608 "TARGET RESET",
6609 "CLEAR TASK SET",
6610 "ABORT TASK SET",
6611 "GET FW STATE",
6612 "GET PORT NAME",
6613 "GET LINK STATUS",
6614 "INIT LIP RESET",
6615 NULL,
6616 "SEND SNS",
6617 "FABRIC LOGIN",
6618 "SEND CHANGE REQUEST",
6619 "FABRIC LOGOUT",
6620 "INIT LIP LOGIN",
6621 NULL,
6622 "LOGIN LOOP PORT",
6623 "GET PORT/NODE NAME LIST",
6624 "SET VENDOR ID",
6625 "INITIALIZE IP MAILBOX",
6626 NULL,
6627 NULL,
6628 NULL,
6629 NULL,
6630 "Get ID List",
6631 "SEND LFA",
6632 "Lun RESET"
6633};
6634
6635static void
6636isp_mboxcmd_qnw(ispsoftc_t *isp, mbreg_t *mbp, int nodelay)
6637{
6638 unsigned int ibits, obits, box, opcode;
6639 const uint32_t *mcp;
6640
6641 if (IS_FC(isp)) {
6642 mcp = mbpfc;
6643 } else {
6644 mcp = mbpscsi;
6645 }
6646 opcode = mbp->param[0];
6647 ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp);
6648 obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp);
6649 ibits |= mbp->ibits;
6650 obits |= mbp->obits;
6651 for (box = 0; box < MAX_MAILBOX(isp); box++) {
6652 if (ibits & (1 << box)) {
6653 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
6654 }
6655 if (nodelay == 0) {
6656 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
6657 }
6658 }
6659 if (nodelay == 0) {
6660 isp->isp_lastmbxcmd = opcode;
6661 isp->isp_obits = obits;
6662 isp->isp_mboxbsy = 1;
6663 }
6664 if (IS_24XX(isp)) {
6665 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
6666 } else {
6667 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
6668 }
6669 /*
6670 * Oddly enough, if we're not delaying for an answer,
6671 * delay a bit to give the f/w a chance to pick up the
6672 * command.
6673 */
6674 if (nodelay) {
6675 USEC_DELAY(1000);
6676 }
6677}
6678
6679static void
6680isp_mboxcmd(ispsoftc_t *isp, mbreg_t *mbp)
6681{
6682 char *cname, *xname, tname[16], mname[16];
6683 unsigned int lim, ibits, obits, box, opcode;
6684 const uint32_t *mcp;
6685
6686 if (IS_FC(isp)) {
6687 mcp = mbpfc;
6688 lim = (sizeof (mbpfc) / sizeof (mbpfc[0]));
6689 } else {
6690 mcp = mbpscsi;
6691 lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0]));
6692 }
6693
6694 if ((opcode = mbp->param[0]) >= lim) {
6695 mbp->param[0] = MBOX_INVALID_COMMAND;
6696 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
6697 return;
6698 }
6699
6700 ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp);
6701 obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp);
6702
6703 /*
6704 * Pick up any additional bits that the caller might have set.
6705 */
6706 ibits |= mbp->ibits;
6707 obits |= mbp->obits;
6708
6709 if (ibits == 0 && obits == 0) {
6710 mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
6711 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
6712 return;
6713 }
6714
6715 /*
6716 * Get exclusive usage of mailbox registers.
6717 */
6718 if (MBOX_ACQUIRE(isp)) {
6719 mbp->param[0] = MBOX_REGS_BUSY;
6720 goto out;
6721 }
6722
6723 for (box = 0; box < MAX_MAILBOX(isp); box++) {
6724 if (ibits & (1 << box)) {
6725 isp_prt(isp, ISP_LOGDEBUG1, "IN mbox %d = 0x%04x", box,
6726 mbp->param[box]);
6727 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
6728 }
6729 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
6730 }
6731
6732 isp->isp_lastmbxcmd = opcode;
6733
6734 /*
6735 * We assume that we can't overwrite a previous command.
6736 */
6737 isp->isp_obits = obits;
6738 isp->isp_mboxbsy = 1;
6739
6740 /*
6741 * Set Host Interrupt condition so that RISC will pick up mailbox regs.
6742 */
6743 if (IS_24XX(isp)) {
6744 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
6745 } else {
6746 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
6747 }
6748
6749 /*
6750 * While we haven't finished the command, spin our wheels here.
6751 */
6752 MBOX_WAIT_COMPLETE(isp, mbp);
6753
6754 /*
6755 * Did the command time out?
6756 */
6757 if (mbp->param[0] == MBOX_TIMEOUT) {
6758 MBOX_RELEASE(isp);
6759 goto out;
6760 }
6761
6762 /*
6763 * Copy back output registers.
6764 */
6765 for (box = 0; box < MAX_MAILBOX(isp); box++) {
6766 if (obits & (1 << box)) {
6767 mbp->param[box] = isp->isp_mboxtmp[box];
6768 isp_prt(isp, ISP_LOGDEBUG1, "OUT mbox %d = 0x%04x", box,
6769 mbp->param[box]);
6770 }
6771 }
6772
6773 MBOX_RELEASE(isp);
6774 out:
6775 isp->isp_mboxbsy = 0;
6776 if (mbp->logval == 0 || opcode == MBOX_EXEC_FIRMWARE) {
6777 return;
6778 }
6779 cname = (IS_FC(isp))? fc_mbcmd_names[opcode] : scsi_mbcmd_names[opcode];
6780 if (cname == NULL) {
6781 cname = tname;
6782 SNPRINTF(tname, sizeof tname, "opcode %x", opcode);
6783 }
6784
6785 /*
6786 * Just to be chatty here...
6787 */
6788 xname = NULL;
6789 switch (mbp->param[0]) {
6790 case MBOX_COMMAND_COMPLETE:
6791 break;
6792 case MBOX_INVALID_COMMAND:
6793 if (mbp->logval & MBLOGMASK(MBOX_COMMAND_COMPLETE)) {
6794 xname = "INVALID COMMAND";
6795 }
6796 break;
6797 case MBOX_HOST_INTERFACE_ERROR:
6798 if (mbp->logval & MBLOGMASK(MBOX_HOST_INTERFACE_ERROR)) {
6799 xname = "HOST INTERFACE ERROR";
6800 }
6801 break;
6802 case MBOX_TEST_FAILED:
6803 if (mbp->logval & MBLOGMASK(MBOX_TEST_FAILED)) {
6804 xname = "TEST FAILED";
6805 }
6806 break;
6807 case MBOX_COMMAND_ERROR:
6808 if (mbp->logval & MBLOGMASK(MBOX_COMMAND_ERROR)) {
6809 xname = "COMMAND ERROR";
6810 }
6811 break;
6812 case MBOX_COMMAND_PARAM_ERROR:
6813 if (mbp->logval & MBLOGMASK(MBOX_COMMAND_PARAM_ERROR)) {
6814 xname = "COMMAND PARAMETER ERROR";
6815 }
6816 break;
6817 case MBOX_LOOP_ID_USED:
6818 if (mbp->logval & MBLOGMASK(MBOX_LOOP_ID_USED)) {
6819 xname = "LOOP ID ALREADY IN USE";
6820 }
6821 break;
6822 case MBOX_PORT_ID_USED:
6823 if (mbp->logval & MBLOGMASK(MBOX_PORT_ID_USED)) {
6824 xname = "PORT ID ALREADY IN USE";
6825 }
6826 break;
6827 case MBOX_ALL_IDS_USED:
6828 if (mbp->logval & MBLOGMASK(MBOX_ALL_IDS_USED)) {
6829 xname = "ALL LOOP IDS IN USE";
6830 }
6831 break;
6832 case MBOX_REGS_BUSY:
6833 xname = "REGISTERS BUSY";
6834 break;
6835 case MBOX_TIMEOUT:
6836 xname = "TIMEOUT";
6837 break;
6838 default:
6839 SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
6840 xname = mname;
6841 break;
6842 }
6843 if (xname) {
6844 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s)",
6845 cname, xname);
6846 }
6847}
6848
6849static void
6850isp_fw_state(ispsoftc_t *isp)
6851{
6852 if (IS_FC(isp)) {
6853 mbreg_t mbs;
6854 fcparam *fcp = isp->isp_param;
6855
6856 MEMZERO(&mbs, sizeof (mbs));
6857 mbs.param[0] = MBOX_GET_FW_STATE;
6858 mbs.logval = MBLOGALL;
6859 isp_mboxcmd(isp, &mbs);
6860 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
6861 fcp->isp_fwstate = mbs.param[1];
6862 }
6863 }
6864}
6865
6866static void
6867isp_update(ispsoftc_t *isp)
6868{
6869 int bus, upmask;
6870
6871 for (bus = 0, upmask = isp->isp_update; upmask != 0; bus++) {
6872 if (upmask & (1 << bus)) {
6873 isp_update_bus(isp, bus);
6874 }
6875 upmask &= ~(1 << bus);
6876 }
6877}
6878
6879static void
6880isp_update_bus(ispsoftc_t *isp, int bus)
6881{
6882 int tgt;
6883 mbreg_t mbs;
6884 sdparam *sdp;
6885
6886 isp->isp_update &= ~(1 << bus);
6887 if (IS_FC(isp)) {
6888 /*
6889 * There are no 'per-bus' settings for Fibre Channel.
6890 */
6891 return;
6892 }
6893 sdp = isp->isp_param;
6894 sdp += bus;
6895
6896 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
6897 uint16_t flags, period, offset;
6898 int get;
6899
6900 if (sdp->isp_devparam[tgt].dev_enable == 0) {
6901 sdp->isp_devparam[tgt].dev_update = 0;
6902 sdp->isp_devparam[tgt].dev_refresh = 0;
6903 isp_prt(isp, ISP_LOGDEBUG0,
6904 "skipping target %d bus %d update", tgt, bus);
6905 continue;
6906 }
6907 /*
6908 * If the goal is to update the status of the device,
6909 * take what's in goal_flags and try and set the device
6910 * toward that. Otherwise, if we're just refreshing the
6911 * current device state, get the current parameters.
6912 */
6913
6914 MEMZERO(&mbs, sizeof (mbs));
6915
6916 /*
6917 * Refresh overrides set
6918 */
6919 if (sdp->isp_devparam[tgt].dev_refresh) {
6920 mbs.param[0] = MBOX_GET_TARGET_PARAMS;
6921 get = 1;
6922 } else if (sdp->isp_devparam[tgt].dev_update) {
6923 mbs.param[0] = MBOX_SET_TARGET_PARAMS;
6924
6925 /*
6926 * Make sure goal_flags has "Renegotiate on Error"
6927 * on and "Freeze Queue on Error" off.
6928 */
6929 sdp->isp_devparam[tgt].goal_flags |= DPARM_RENEG;
6930 sdp->isp_devparam[tgt].goal_flags &= ~DPARM_QFRZ;
6931 mbs.param[2] = sdp->isp_devparam[tgt].goal_flags;
6932
6933 /*
6934 * Insist that PARITY must be enabled
6935 * if SYNC or WIDE is enabled.
6936 */
6937 if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) {
6938 mbs.param[2] |= DPARM_PARITY;
6939 }
6940
6941 if (mbs.param[2] & DPARM_SYNC) {
6942 mbs.param[3] =
6943 (sdp->isp_devparam[tgt].goal_offset << 8) |
6944 (sdp->isp_devparam[tgt].goal_period);
6945 }
6946 /*
6947 * A command completion later that has
6948 * RQSTF_NEGOTIATION set can cause
6949 * the dev_refresh/announce cycle also.
6950 *
6951 * Note: It is really important to update our current
6952 * flags with at least the state of TAG capabilities-
6953 * otherwise we might try and send a tagged command
6954 * when we have it all turned off. So change it here
6955 * to say that current already matches goal.
6956 */
6957 sdp->isp_devparam[tgt].actv_flags &= ~DPARM_TQING;
6958 sdp->isp_devparam[tgt].actv_flags |=
6959 (sdp->isp_devparam[tgt].goal_flags & DPARM_TQING);
6960 isp_prt(isp, ISP_LOGDEBUG0,
6961 "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
6962 bus, tgt, mbs.param[2], mbs.param[3] >> 8,
6963 mbs.param[3] & 0xff);
6964 get = 0;
6965 } else {
6966 continue;
6967 }
6968 mbs.param[1] = (bus << 15) | (tgt << 8);
6969 mbs.logval = MBLOGALL;
6970 isp_mboxcmd(isp, &mbs);
6971 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
6972 continue;
6973 }
6974 if (get == 0) {
6975 isp->isp_sendmarker |= (1 << bus);
6976 sdp->isp_devparam[tgt].dev_update = 0;
6977 sdp->isp_devparam[tgt].dev_refresh = 1;
6978 } else {
6979 sdp->isp_devparam[tgt].dev_refresh = 0;
6980 flags = mbs.param[2];
6981 period = mbs.param[3] & 0xff;
6982 offset = mbs.param[3] >> 8;
6983 sdp->isp_devparam[tgt].actv_flags = flags;
6984 sdp->isp_devparam[tgt].actv_period = period;
6985 sdp->isp_devparam[tgt].actv_offset = offset;
6986 get = (bus << 16) | tgt;
6987 (void) isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &get);
6988 }
6989 }
6990
6991 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
6992 if (sdp->isp_devparam[tgt].dev_update ||
6993 sdp->isp_devparam[tgt].dev_refresh) {
6994 isp->isp_update |= (1 << bus);
6995 break;
6996 }
6997 }
6998}
6999
7000#ifndef DEFAULT_FRAMESIZE
7001#define DEFAULT_FRAMESIZE(isp) ICB_DFLT_FRMLEN
7002#endif
7003#ifndef DEFAULT_EXEC_THROTTLE
7004#define DEFAULT_EXEC_THROTTLE(isp) ISP_EXEC_THROTTLE
7005#endif
7006
7007static void
7008isp_setdfltparm(ispsoftc_t *isp, int channel)
7009{
7010 int tgt;
7011 sdparam *sdp;
7012
7013 if (IS_FC(isp)) {
7014 fcparam *fcp = (fcparam *) isp->isp_param;
7015 int nvfail;
7016
7017 fcp += channel;
7018 if (fcp->isp_gotdparms) {
7019 return;
7020 }
7021 fcp->isp_gotdparms = 1;
7022 fcp->isp_maxfrmlen = DEFAULT_FRAMESIZE(isp);
7023 fcp->isp_maxalloc = ICB_DFLT_ALLOC;
7024 fcp->isp_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
7025 fcp->isp_retry_delay = ICB_DFLT_RDELAY;
7026 fcp->isp_retry_count = ICB_DFLT_RCOUNT;
7027 /* Platform specific.... */
7028 fcp->isp_loopid = DEFAULT_LOOPID(isp);
7029 fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp);
7030 fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp);
7031 fcp->isp_fwoptions = 0;
7032 fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
7033 fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
7034 fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
7035 fcp->isp_fwoptions |= ICBOPT_FAST_POST;
7036 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX) {
7037 fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
7038 }
7039
7040 /*
7041 * Make sure this is turned off now until we get
7042 * extended options from NVRAM
7043 */
7044 fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
7045
7046 /*
7047 * Now try and read NVRAM unless told to not do so.
7048 * This will set fcparam's isp_wwnn_nvram && isp_wwpn_nvram.
7049 */
7050 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7051 nvfail = isp_read_nvram(isp);
7052 if (nvfail) {
7053 isp->isp_confopts |= ISP_CFG_NONVRAM;
7054 }
7055 } else {
7056 nvfail = 1;
7057 }
7058 /*
7059 * Set node && port to override platform set defaults
7060 * unless the nvram read failed (or none was done),
7061 * or the platform code wants to use what had been
7062 * set in the defaults.
7063 */
7064 if (nvfail) {
7065 isp->isp_confopts |= ISP_CFG_OWNWWPN|ISP_CFG_OWNWWNN;
7066 }
7067 if (isp->isp_confopts & ISP_CFG_OWNWWNN) {
7068 isp_prt(isp, ISP_LOGCONFIG, "Using Node WWN 0x%08x%08x",
7069 (uint32_t) (DEFAULT_NODEWWN(isp) >> 32),
7070 (uint32_t) (DEFAULT_NODEWWN(isp) & 0xffffffff));
7071 ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp);
7072 } else {
7073 /*
7074 * We always start out with values derived
7075 * from NVRAM or our platform default.
7076 */
7077 ISP_NODEWWN(isp) = fcp->isp_wwnn_nvram;
7078 if (fcp->isp_wwnn_nvram == 0) {
7079 isp_prt(isp, ISP_LOGCONFIG,
7080 "bad WWNN- using default");
7081 ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp);
7082 }
7083 }
7084 if (isp->isp_confopts & ISP_CFG_OWNWWPN) {
7085 isp_prt(isp, ISP_LOGCONFIG, "Using Port WWN 0x%08x%08x",
7086 (uint32_t) (DEFAULT_PORTWWN(isp) >> 32),
7087 (uint32_t) (DEFAULT_PORTWWN(isp) & 0xffffffff));
7088 ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp);
7089 } else {
7090 /*
7091 * We always start out with values derived
7092 * from NVRAM or our platform default.
7093 */
7094 ISP_PORTWWN(isp) = fcp->isp_wwpn_nvram;
7095 if (fcp->isp_wwpn_nvram == 0) {
7096 isp_prt(isp, ISP_LOGCONFIG,
7097 "bad WWPN- using default");
7098 ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp);
7099 }
7100 }
7101 return;
7102 }
7103
7104 sdp = (sdparam *) isp->isp_param;
7105 sdp += channel;
7106
7107 /*
7108 * Been there, done that, got the T-shirt...
7109 */
7110 if (sdp->isp_gotdparms) {
7111 return;
7112 }
7113 sdp->isp_gotdparms = 1;
7114
7115 /*
7116 * Establish some default parameters.
7117 */
7118 sdp->isp_cmd_dma_burst_enable = 0;
7119 sdp->isp_data_dma_burst_enabl = 1;
7120 sdp->isp_fifo_threshold = 0;
7121 sdp->isp_initiator_id = DEFAULT_IID(isp);
7122 if (isp->isp_type >= ISP_HA_SCSI_1040) {
7123 sdp->isp_async_data_setup = 9;
7124 } else {
7125 sdp->isp_async_data_setup = 6;
7126 }
7127 sdp->isp_selection_timeout = 250;
7128 sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
7129 sdp->isp_tag_aging = 8;
7130 sdp->isp_bus_reset_delay = 5;
7131 /*
7132 * Don't retry selection, busy or queue full automatically- reflect
7133 * these back to us.
7134 */
7135 sdp->isp_retry_count = 0;
7136 sdp->isp_retry_delay = 0;
7137
7138 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7139 sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE;
7140 sdp->isp_devparam[tgt].dev_enable = 1;
7141 }
7142
7143 /*
7144 * If we've not been told to avoid reading NVRAM, try and read it.
7145 * If we're successful reading it, we can then return because NVRAM
7146 * will tell us what the desired settings are. Otherwise, we establish
7147 * some reasonable 'fake' nvram and goal defaults.
7148 */
7149
7150 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7151 if (isp_read_nvram(isp) == 0) {
7152 return;
7153 }
7154 }
7155
7156 /*
7157 * Now try and see whether we have specific values for them.
7158 */
7159 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7160 mbreg_t mbs;
7161
7162 MEMZERO(&mbs, sizeof (mbs));
7163 mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
7164 mbs.logval = MBLOGNONE;
7165 isp_mboxcmd(isp, &mbs);
7166 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
7167 sdp->isp_req_ack_active_neg = 1;
7168 sdp->isp_data_line_active_neg = 1;
7169 } else {
7170 sdp->isp_req_ack_active_neg =
7171 (mbs.param[1+channel] >> 4) & 0x1;
7172 sdp->isp_data_line_active_neg =
7173 (mbs.param[1+channel] >> 5) & 0x1;
7174 }
7175 }
7176
7177 isp_prt(isp, ISP_LOGDEBUG0, sc0, sc3,
7178 0, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
7179 sdp->isp_bus_reset_delay, sdp->isp_retry_count,
7180 sdp->isp_retry_delay, sdp->isp_async_data_setup);
7181 isp_prt(isp, ISP_LOGDEBUG0, sc1, sc3,
7182 sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
7183 sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
7184 sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
7185
7186 /*
7187 * The trick here is to establish a default for the default (honk!)
7188 * state (goal_flags). Then try and get the current status from
7189 * the card to fill in the current state. We don't, in fact, set
7190 * the default to the SAFE default state- that's not the goal state.
7191 */
7192 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7193 uint8_t off, per;
7194 sdp->isp_devparam[tgt].actv_offset = 0;
7195 sdp->isp_devparam[tgt].actv_period = 0;
7196 sdp->isp_devparam[tgt].actv_flags = 0;
7197
7198 sdp->isp_devparam[tgt].goal_flags =
7199 sdp->isp_devparam[tgt].nvrm_flags = DPARM_DEFAULT;
7200
7201 /*
7202 * We default to Wide/Fast for versions less than a 1040
7203 * (unless it's SBus).
7204 */
7205 if (IS_ULTRA3(isp)) {
7206 off = ISP_80M_SYNCPARMS >> 8;
7207 per = ISP_80M_SYNCPARMS & 0xff;
7208 } else if (IS_ULTRA2(isp)) {
7209 off = ISP_40M_SYNCPARMS >> 8;
7210 per = ISP_40M_SYNCPARMS & 0xff;
7211 } else if (IS_1240(isp)) {
7212 off = ISP_20M_SYNCPARMS >> 8;
7213 per = ISP_20M_SYNCPARMS & 0xff;
7214 } else if ((isp->isp_bustype == ISP_BT_SBUS &&
7215 isp->isp_type < ISP_HA_SCSI_1020A) ||
7216 (isp->isp_bustype == ISP_BT_PCI &&
7217 isp->isp_type < ISP_HA_SCSI_1040) ||
7218 (isp->isp_clock && isp->isp_clock < 60) ||
7219 (sdp->isp_ultramode == 0)) {
7220 off = ISP_10M_SYNCPARMS >> 8;
7221 per = ISP_10M_SYNCPARMS & 0xff;
7222 } else {
7223 off = ISP_20M_SYNCPARMS_1040 >> 8;
7224 per = ISP_20M_SYNCPARMS_1040 & 0xff;
7225 }
7226 sdp->isp_devparam[tgt].goal_offset =
7227 sdp->isp_devparam[tgt].nvrm_offset = off;
7228 sdp->isp_devparam[tgt].goal_period =
7229 sdp->isp_devparam[tgt].nvrm_period = per;
7230
7231 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc3,
7232 channel, tgt, sdp->isp_devparam[tgt].nvrm_flags,
7233 sdp->isp_devparam[tgt].nvrm_offset,
7234 sdp->isp_devparam[tgt].nvrm_period);
7235 }
7236}
7237
7238/*
7239 * Re-initialize the ISP and complete all orphaned commands
7240 * with a 'botched' notice. The reset/init routines should
7241 * not disturb an already active list of commands.
7242 */
7243
7244void
7245isp_reinit(ispsoftc_t *isp)
7246{
7247 XS_T *xs;
7248 uint32_t tmp;
7249
7250 if (IS_FC(isp)) {
7251 ISP_MARK_PORTDB(isp, 0);
7252 }
7253 isp_reset(isp);
7254 if (isp->isp_state != ISP_RESETSTATE) {
7255 isp_prt(isp, ISP_LOGERR, "isp_reinit cannot reset card");
7256 } else if (isp->isp_role != ISP_ROLE_NONE) {
7257 isp_init(isp);
7258 if (isp->isp_state == ISP_INITSTATE) {
7259 isp->isp_state = ISP_RUNSTATE;
7260 }
7261 if (isp->isp_state != ISP_RUNSTATE) {
7262 isp_prt(isp, ISP_LOGERR,
7263 "isp_reinit cannot restart card");
7264 ISP_DISABLE_INTS(isp);
7265 }
7266 } else {
7267 ISP_DISABLE_INTS(isp);
7268 if (IS_FC(isp)) {
7269 /*
7270 * If we're in ISP_ROLE_NONE, turn off the lasers.
7271 */
7272 if (!IS_24XX(isp)) {
7273 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
7274 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
7275 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
7276 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
7277 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
7278 }
7279 }
7280 }
7281 isp->isp_nactive = 0;
7282
7283 for (tmp = 0; tmp < isp->isp_maxcmds; tmp++) {
7284 uint32_t handle;
7285
7286 xs = isp->isp_xflist[tmp];
7287 if (xs == NULL) {
7288 continue;
7289 }
7290 handle = isp_find_handle(isp, xs);
7291 if (handle == 0) {
7292 continue;
7293 }
7294 isp_destroy_handle(isp, handle);
7295 if (XS_XFRLEN(xs)) {
7296 ISP_DMAFREE(isp, xs, handle);
7297 XS_RESID(xs) = XS_XFRLEN(xs);
7298 } else {
7299 XS_RESID(xs) = 0;
7300 }
7301 XS_SETERR(xs, HBA_BUSRESET);
7302 isp_done(xs);
7303 }
7304#ifdef ISP_TARGET_MODE
7305 MEMZERO(isp->isp_tgtlist, isp->isp_maxcmds * sizeof (void **));
7306#endif
7307}
7308
7309/*
7310 * NVRAM Routines
7311 */
7312static int
7313isp_read_nvram(ispsoftc_t *isp)
7314{
7315 int i, amt, retval;
7316 uint8_t csum, minversion;
7317 union {
7318 uint8_t _x[ISP2100_NVRAM_SIZE];
7319 uint16_t _s[ISP2100_NVRAM_SIZE>>1];
7320 } _n;
7321#define nvram_data _n._x
7322#define nvram_words _n._s
7323
7324 if (IS_24XX(isp)) {
7325 return (isp_read_nvram_2400(isp));
7326 } else if (IS_FC(isp)) {
7327 amt = ISP2100_NVRAM_SIZE;
7328 minversion = 1;
7329 } else if (IS_ULTRA2(isp)) {
7330 amt = ISP1080_NVRAM_SIZE;
7331 minversion = 0;
7332 } else {
7333 amt = ISP_NVRAM_SIZE;
7334 minversion = 2;
7335 }
7336
7337 for (i = 0; i < amt>>1; i++) {
7338 isp_rdnvram_word(isp, i, &nvram_words[i]);
7339 }
7340
7341 if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7342 nvram_data[2] != 'P') {
7343 if (isp->isp_bustype != ISP_BT_SBUS) {
7344 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
7345 isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x",
7346 nvram_data[0], nvram_data[1], nvram_data[2]);
7347 }
7348 retval = -1;
7349 goto out;
7350 }
7351
7352 for (csum = 0, i = 0; i < amt; i++) {
7353 csum += nvram_data[i];
7354 }
7355 if (csum != 0) {
7356 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7357 retval = -1;
7358 goto out;
7359 }
7360
7361 if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
7362 isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
7363 ISP_NVRAM_VERSION(nvram_data));
7364 retval = -1;
7365 goto out;
7366 }
7367
7368 if (IS_ULTRA3(isp)) {
7369 isp_parse_nvram_12160(isp, 0, nvram_data);
7370 if (IS_12160(isp))
7371 isp_parse_nvram_12160(isp, 1, nvram_data);
7372 } else if (IS_1080(isp)) {
7373 isp_parse_nvram_1080(isp, 0, nvram_data);
7374 } else if (IS_1280(isp) || IS_1240(isp)) {
7375 isp_parse_nvram_1080(isp, 0, nvram_data);
7376 isp_parse_nvram_1080(isp, 1, nvram_data);
7377 } else if (IS_SCSI(isp)) {
7378 isp_parse_nvram_1020(isp, nvram_data);
7379 } else {
7380 isp_parse_nvram_2100(isp, nvram_data);
7381 }
7382 retval = 0;
7383out:
7384 return (retval);
7385#undef nvram_data
7386#undef nvram_words
7387}
7388
7389static int
7390isp_read_nvram_2400(ispsoftc_t *isp)
7391{
7392 uint8_t *nvram_data = FCPARAM(isp)->isp_scratch;
7393 int retval = 0;
7394 uint32_t addr, csum, lwrds, *dptr;
7395
7396 if (isp->isp_port) {
7397 addr = ISP2400_NVRAM_PORT1_ADDR;
7398 } else {
7399 addr = ISP2400_NVRAM_PORT0_ADDR;
7400 }
7401
7402 dptr = (uint32_t *) nvram_data;
7403 for (lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7404 isp_rd_2400_nvram(isp, addr++, dptr++);
7405 }
7406 if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7407 nvram_data[2] != 'P') {
7408 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
7409 retval = -1;
7410 goto out;
7411 }
7412 dptr = (uint32_t *) nvram_data;
7413 for (csum = 0, lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7414 csum += dptr[lwrds];
7415 }
7416 if (csum != 0) {
7417 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7418 retval = -1;
7419 goto out;
7420 }
7421 isp_parse_nvram_2400(isp, nvram_data);
7422out:
7423 return (retval);
7424}
7425
7426static void
7427isp_rdnvram_word(ispsoftc_t *isp, int wo, uint16_t *rp)
7428{
7429 int i, cbits;
7430 uint16_t bit, rqst, junk;
7431
7432 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7433 USEC_DELAY(10);
7434 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7435 USEC_DELAY(10);
7436
7437 if (IS_FC(isp)) {
7438 wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
7439 if (IS_2312(isp) && isp->isp_port) {
7440 wo += 128;
7441 }
7442 rqst = (ISP_NVRAM_READ << 8) | wo;
7443 cbits = 10;
7444 } else if (IS_ULTRA2(isp)) {
7445 wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1);
7446 rqst = (ISP_NVRAM_READ << 8) | wo;
7447 cbits = 10;
7448 } else {
7449 wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
7450 rqst = (ISP_NVRAM_READ << 6) | wo;
7451 cbits = 8;
7452 }
7453
7454 /*
7455 * Clock the word select request out...
7456 */
7457 for (i = cbits; i >= 0; i--) {
7458 if ((rqst >> i) & 1) {
7459 bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
7460 } else {
7461 bit = BIU_NVRAM_SELECT;
7462 }
7463 ISP_WRITE(isp, BIU_NVRAM, bit);
7464 USEC_DELAY(10);
7465 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7466 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
7467 USEC_DELAY(10);
7468 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7469 ISP_WRITE(isp, BIU_NVRAM, bit);
7470 USEC_DELAY(10);
7471 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7472 }
7473 /*
7474 * Now read the result back in (bits come back in MSB format).
7475 */
7476 *rp = 0;
7477 for (i = 0; i < 16; i++) {
7478 uint16_t rv;
7479 *rp <<= 1;
7480 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7481 USEC_DELAY(10);
7482 rv = ISP_READ(isp, BIU_NVRAM);
7483 if (rv & BIU_NVRAM_DATAIN) {
7484 *rp |= 1;
7485 }
7486 USEC_DELAY(10);
7487 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7488 USEC_DELAY(10);
7489 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7490 }
7491 ISP_WRITE(isp, BIU_NVRAM, 0);
7492 USEC_DELAY(10);
7493 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7494 ISP_SWIZZLE_NVRAM_WORD(isp, rp);
7495}
7496
7497static void
7498isp_rd_2400_nvram(ispsoftc_t *isp, uint32_t addr, uint32_t *rp)
7499{
7500 int loops = 0;
7501 const uint32_t base = 0x7ffe0000;
7502 uint32_t tmp;
7503
7504 ISP_WRITE(isp, BIU2400_FLASH_ADDR, base | addr);
7505 for (loops = 0; loops < 5000; loops++) {
7506 USEC_DELAY(10);
7507 tmp = ISP_READ(isp, BIU2400_FLASH_ADDR);
|
7526 if ((tmp & (1 << 31)) != 0) {
| 7508 if ((tmp & (1U << 31)) != 0) {
|
7527 break;
7528 }
7529 }
| 7509 break;
7510 }
7511 }
|
7530 if (tmp & (1 << 31)) {
| 7512 if (tmp & (1U << 31)) {
|
7531 tmp = ISP_READ(isp, BIU2400_FLASH_DATA);
7532 *rp = tmp;
7533 } else {
7534 *rp = 0xffffffff;
7535 }
7536}
7537
7538static void
7539isp_parse_nvram_1020(ispsoftc_t *isp, uint8_t *nvram_data)
7540{
7541 sdparam *sdp = (sdparam *) isp->isp_param;
7542 int tgt;
7543
7544 sdp->isp_fifo_threshold =
7545 ISP_NVRAM_FIFO_THRESHOLD(nvram_data) |
7546 (ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2);
7547
7548 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7549 sdp->isp_initiator_id =
7550 ISP_NVRAM_INITIATOR_ID(nvram_data);
7551
7552 sdp->isp_bus_reset_delay =
7553 ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
7554
7555 sdp->isp_retry_count =
7556 ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
7557
7558 sdp->isp_retry_delay =
7559 ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
7560
7561 sdp->isp_async_data_setup =
7562 ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
7563
7564 if (isp->isp_type >= ISP_HA_SCSI_1040) {
7565 if (sdp->isp_async_data_setup < 9) {
7566 sdp->isp_async_data_setup = 9;
7567 }
7568 } else {
7569 if (sdp->isp_async_data_setup != 6) {
7570 sdp->isp_async_data_setup = 6;
7571 }
7572 }
7573
7574 sdp->isp_req_ack_active_neg =
7575 ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
7576
7577 sdp->isp_data_line_active_neg =
7578 ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
7579
7580 sdp->isp_data_dma_burst_enabl =
7581 ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
7582
7583 sdp->isp_cmd_dma_burst_enable =
7584 ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
7585
7586 sdp->isp_tag_aging =
7587 ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
7588
7589 sdp->isp_selection_timeout =
7590 ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
7591
7592 sdp->isp_max_queue_depth =
7593 ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
7594
7595 sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
7596
7597 isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
7598 0, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
7599 sdp->isp_bus_reset_delay, sdp->isp_retry_count,
7600 sdp->isp_retry_delay, sdp->isp_async_data_setup);
7601 isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
7602 sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
7603 sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
7604 sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
7605
7606 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7607 sdp->isp_devparam[tgt].dev_enable =
7608 ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt);
7609 sdp->isp_devparam[tgt].exc_throttle =
7610 ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt);
7611 sdp->isp_devparam[tgt].nvrm_offset =
7612 ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt);
7613 sdp->isp_devparam[tgt].nvrm_period =
7614 ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt);
7615 /*
7616 * We probably shouldn't lie about this, but it
7617 * it makes it much safer if we limit NVRAM values
7618 * to sanity.
7619 */
7620 if (isp->isp_type < ISP_HA_SCSI_1040) {
7621 /*
7622 * If we're not ultra, we can't possibly
7623 * be a shorter period than this.
7624 */
7625 if (sdp->isp_devparam[tgt].nvrm_period < 0x19) {
7626 sdp->isp_devparam[tgt].nvrm_period = 0x19;
7627 }
7628 if (sdp->isp_devparam[tgt].nvrm_offset > 0xc) {
7629 sdp->isp_devparam[tgt].nvrm_offset = 0x0c;
7630 }
7631 } else {
7632 if (sdp->isp_devparam[tgt].nvrm_offset > 0x8) {
7633 sdp->isp_devparam[tgt].nvrm_offset = 0x8;
7634 }
7635 }
7636 sdp->isp_devparam[tgt].nvrm_flags = 0;
7637 if (ISP_NVRAM_TGT_RENEG(nvram_data, tgt))
7638 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7639 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7640 if (ISP_NVRAM_TGT_TQING(nvram_data, tgt))
7641 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7642 if (ISP_NVRAM_TGT_SYNC(nvram_data, tgt))
7643 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7644 if (ISP_NVRAM_TGT_WIDE(nvram_data, tgt))
7645 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7646 if (ISP_NVRAM_TGT_PARITY(nvram_data, tgt))
7647 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7648 if (ISP_NVRAM_TGT_DISC(nvram_data, tgt))
7649 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7650 sdp->isp_devparam[tgt].actv_flags = 0; /* we don't know */
7651 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
7652 0, tgt, sdp->isp_devparam[tgt].nvrm_flags,
7653 sdp->isp_devparam[tgt].nvrm_offset,
7654 sdp->isp_devparam[tgt].nvrm_period);
7655 sdp->isp_devparam[tgt].goal_offset =
7656 sdp->isp_devparam[tgt].nvrm_offset;
7657 sdp->isp_devparam[tgt].goal_period =
7658 sdp->isp_devparam[tgt].nvrm_period;
7659 sdp->isp_devparam[tgt].goal_flags =
7660 sdp->isp_devparam[tgt].nvrm_flags;
7661 }
7662}
7663
7664static void
7665isp_parse_nvram_1080(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7666{
7667 sdparam *sdp = (sdparam *) isp->isp_param;
7668 int tgt;
7669
7670 sdp += bus;
7671
7672 sdp->isp_fifo_threshold =
7673 ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data);
7674
7675 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7676 sdp->isp_initiator_id =
7677 ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus);
7678
7679 sdp->isp_bus_reset_delay =
7680 ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7681
7682 sdp->isp_retry_count =
7683 ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7684
7685 sdp->isp_retry_delay =
7686 ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7687
7688 sdp->isp_async_data_setup =
7689 ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7690
7691 sdp->isp_req_ack_active_neg =
7692 ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7693
7694 sdp->isp_data_line_active_neg =
7695 ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7696
7697 sdp->isp_data_dma_burst_enabl =
7698 ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7699
7700 sdp->isp_cmd_dma_burst_enable =
7701 ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7702
7703 sdp->isp_selection_timeout =
7704 ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
7705
7706 sdp->isp_max_queue_depth =
7707 ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
7708
7709 isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
7710 bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
7711 sdp->isp_bus_reset_delay, sdp->isp_retry_count,
7712 sdp->isp_retry_delay, sdp->isp_async_data_setup);
7713 isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
7714 sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
7715 sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
7716 sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
7717
7718
7719 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7720 sdp->isp_devparam[tgt].dev_enable =
7721 ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
7722 sdp->isp_devparam[tgt].exc_throttle =
7723 ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
7724 sdp->isp_devparam[tgt].nvrm_offset =
7725 ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
7726 sdp->isp_devparam[tgt].nvrm_period =
7727 ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
7728 sdp->isp_devparam[tgt].nvrm_flags = 0;
7729 if (ISP1080_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
7730 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7731 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7732 if (ISP1080_NVRAM_TGT_TQING(nvram_data, tgt, bus))
7733 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7734 if (ISP1080_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
7735 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7736 if (ISP1080_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
7737 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7738 if (ISP1080_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
7739 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7740 if (ISP1080_NVRAM_TGT_DISC(nvram_data, tgt, bus))
7741 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7742 sdp->isp_devparam[tgt].actv_flags = 0;
7743 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
7744 bus, tgt, sdp->isp_devparam[tgt].nvrm_flags,
7745 sdp->isp_devparam[tgt].nvrm_offset,
7746 sdp->isp_devparam[tgt].nvrm_period);
7747 sdp->isp_devparam[tgt].goal_offset =
7748 sdp->isp_devparam[tgt].nvrm_offset;
7749 sdp->isp_devparam[tgt].goal_period =
7750 sdp->isp_devparam[tgt].nvrm_period;
7751 sdp->isp_devparam[tgt].goal_flags =
7752 sdp->isp_devparam[tgt].nvrm_flags;
7753 }
7754}
7755
7756static void
7757isp_parse_nvram_12160(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7758{
7759 sdparam *sdp = (sdparam *) isp->isp_param;
7760 int tgt;
7761
7762 sdp += bus;
7763
7764 sdp->isp_fifo_threshold =
7765 ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data);
7766
7767 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7768 sdp->isp_initiator_id =
7769 ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus);
7770
7771 sdp->isp_bus_reset_delay =
7772 ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7773
7774 sdp->isp_retry_count =
7775 ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7776
7777 sdp->isp_retry_delay =
7778 ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7779
7780 sdp->isp_async_data_setup =
7781 ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7782
7783 sdp->isp_req_ack_active_neg =
7784 ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7785
7786 sdp->isp_data_line_active_neg =
7787 ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7788
7789 sdp->isp_data_dma_burst_enabl =
7790 ISP12160_NVRAM_BURST_ENABLE(nvram_data);
7791
7792 sdp->isp_cmd_dma_burst_enable =
7793 ISP12160_NVRAM_BURST_ENABLE(nvram_data);
7794
7795 sdp->isp_selection_timeout =
7796 ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
7797
7798 sdp->isp_max_queue_depth =
7799 ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
7800
7801 isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
7802 bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
7803 sdp->isp_bus_reset_delay, sdp->isp_retry_count,
7804 sdp->isp_retry_delay, sdp->isp_async_data_setup);
7805 isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
7806 sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
7807 sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
7808 sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
7809
7810 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7811 sdp->isp_devparam[tgt].dev_enable =
7812 ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
7813 sdp->isp_devparam[tgt].exc_throttle =
7814 ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
7815 sdp->isp_devparam[tgt].nvrm_offset =
7816 ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
7817 sdp->isp_devparam[tgt].nvrm_period =
7818 ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
7819 sdp->isp_devparam[tgt].nvrm_flags = 0;
7820 if (ISP12160_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
7821 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7822 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7823 if (ISP12160_NVRAM_TGT_TQING(nvram_data, tgt, bus))
7824 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7825 if (ISP12160_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
7826 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7827 if (ISP12160_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
7828 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7829 if (ISP12160_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
7830 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7831 if (ISP12160_NVRAM_TGT_DISC(nvram_data, tgt, bus))
7832 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7833 sdp->isp_devparam[tgt].actv_flags = 0;
7834 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
7835 bus, tgt, sdp->isp_devparam[tgt].nvrm_flags,
7836 sdp->isp_devparam[tgt].nvrm_offset,
7837 sdp->isp_devparam[tgt].nvrm_period);
7838 sdp->isp_devparam[tgt].goal_offset =
7839 sdp->isp_devparam[tgt].nvrm_offset;
7840 sdp->isp_devparam[tgt].goal_period =
7841 sdp->isp_devparam[tgt].nvrm_period;
7842 sdp->isp_devparam[tgt].goal_flags =
7843 sdp->isp_devparam[tgt].nvrm_flags;
7844 }
7845}
7846
7847static void
7848isp_fix_nvram_wwns(ispsoftc_t *isp)
7849{
7850 fcparam *fcp = FCPARAM(isp);
7851
7852 /*
7853 * Make sure we have both Node and Port as non-zero values.
7854 */
7855 if (fcp->isp_wwnn_nvram != 0 && fcp->isp_wwpn_nvram == 0) {
7856 fcp->isp_wwpn_nvram = fcp->isp_wwnn_nvram;
7857 } else if (fcp->isp_wwnn_nvram == 0 && fcp->isp_wwpn_nvram != 0) {
7858 fcp->isp_wwnn_nvram = fcp->isp_wwpn_nvram;
7859 }
7860
7861 /*
7862 * Make the Node and Port values sane if they're NAA == 2.
7863 * This means to clear bits 48..56 for the Node WWN and
7864 * make sure that there's some non-zero value in 48..56
7865 * for the Port WWN.
7866 */
7867 if (fcp->isp_wwnn_nvram && fcp->isp_wwpn_nvram) {
7868 if ((fcp->isp_wwnn_nvram & (((uint64_t) 0xfff) << 48)) != 0 &&
7869 (fcp->isp_wwnn_nvram >> 60) == 2) {
7870 fcp->isp_wwnn_nvram &= ~((uint64_t) 0xfff << 48);
7871 }
7872 if ((fcp->isp_wwpn_nvram & (((uint64_t) 0xfff) << 48)) == 0 &&
7873 (fcp->isp_wwpn_nvram >> 60) == 2) {
7874 fcp->isp_wwpn_nvram |= ((uint64_t) 1 << 56);
7875 }
7876 }
7877}
7878
7879static void
7880isp_parse_nvram_2100(ispsoftc_t *isp, uint8_t *nvram_data)
7881{
7882 fcparam *fcp = FCPARAM(isp);
7883 uint64_t wwn;
7884
7885 /*
7886 * There is NVRAM storage for both Port and Node entities-
7887 * but the Node entity appears to be unused on all the cards
7888 * I can find. However, we should account for this being set
7889 * at some point in the future.
7890 *
7891 * Qlogic WWNs have an NAA of 2, but usually nothing shows up in
7892 * bits 48..60. In the case of the 2202, it appears that they do
7893 * use bit 48 to distinguish between the two instances on the card.
7894 * The 2204, which I've never seen, *probably* extends this method.
7895 */
7896 wwn = ISP2100_NVRAM_PORT_NAME(nvram_data);
7897 if (wwn) {
7898 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
7899 (uint32_t) (wwn >> 32), (uint32_t) (wwn & 0xffffffff));
7900 if ((wwn >> 60) == 0) {
7901 wwn |= (((uint64_t) 2)<< 60);
7902 }
7903 }
7904 fcp->isp_wwpn_nvram = wwn;
7905 if (IS_2200(isp) || IS_23XX(isp)) {
7906 wwn = ISP2100_NVRAM_NODE_NAME(nvram_data);
7907 if (wwn) {
7908 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
7909 (uint32_t) (wwn >> 32),
7910 (uint32_t) (wwn & 0xffffffff));
7911 if ((wwn >> 60) == 0) {
7912 wwn |= (((uint64_t) 2)<< 60);
7913 }
7914 }
7915 } else {
7916 wwn &= ~((uint64_t) 0xfff << 48);
7917 }
7918 fcp->isp_wwnn_nvram = wwn;
7919
7920 isp_fix_nvram_wwns(isp);
7921
7922 fcp->isp_maxalloc = ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
7923 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
7924 fcp->isp_maxfrmlen = ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
7925 }
7926 fcp->isp_retry_delay = ISP2100_NVRAM_RETRY_DELAY(nvram_data);
7927 fcp->isp_retry_count = ISP2100_NVRAM_RETRY_COUNT(nvram_data);
7928 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
7929 fcp->isp_loopid = ISP2100_NVRAM_HARDLOOPID(nvram_data);
7930 }
7931 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
7932 fcp->isp_execthrottle =
7933 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
7934 }
7935 fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
7936 isp_prt(isp, ISP_LOGDEBUG0,
7937 "NVRAM 0x%08x%08x 0x%08x%08x maxalloc %d maxframelen %d",
7938 (uint32_t) (fcp->isp_wwnn_nvram >> 32), (uint32_t) fcp->isp_wwnn_nvram,
7939 (uint32_t) (fcp->isp_wwpn_nvram >> 32), (uint32_t) fcp->isp_wwpn_nvram,
7940 ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data),
7941 ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data));
7942 isp_prt(isp, ISP_LOGDEBUG0,
7943 "execthrottle %d fwoptions 0x%x hardloop %d tov %d",
7944 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data),
7945 ISP2100_NVRAM_OPTIONS(nvram_data),
7946 ISP2100_NVRAM_HARDLOOPID(nvram_data),
7947 ISP2100_NVRAM_TOV(nvram_data));
7948 fcp->isp_xfwoptions = ISP2100_XFW_OPTIONS(nvram_data);
7949 fcp->isp_zfwoptions = ISP2100_ZFW_OPTIONS(nvram_data);
7950 isp_prt(isp, ISP_LOGDEBUG0,
7951 "xfwoptions 0x%x zfw options 0x%x",
7952 ISP2100_XFW_OPTIONS(nvram_data), ISP2100_ZFW_OPTIONS(nvram_data));
7953}
7954
7955static void
7956isp_parse_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
7957{
7958 fcparam *fcp = FCPARAM(isp);
7959 uint64_t wwn;
7960
7961 isp_prt(isp, ISP_LOGDEBUG0,
7962 "NVRAM 0x%08x%08x 0x%08x%08x exchg_cnt %d maxframelen %d",
7963 (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data) >> 32),
7964 (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data)),
7965 (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data) >> 32),
7966 (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data)),
7967 ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data),
7968 ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data));
7969 isp_prt(isp, ISP_LOGDEBUG0,
7970 "NVRAM execthr %d loopid %d fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
7971 ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data),
7972 ISP2400_NVRAM_HARDLOOPID(nvram_data),
7973 ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data),
7974 ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data),
7975 ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data));
7976
7977 wwn = ISP2400_NVRAM_PORT_NAME(nvram_data);
7978 if (wwn) {
7979 if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
7980 wwn = 0;
7981 }
7982 }
7983 fcp->isp_wwpn_nvram = wwn;
7984
7985 wwn = ISP2400_NVRAM_NODE_NAME(nvram_data);
7986 if (wwn) {
7987 if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
7988 wwn = 0;
7989 }
7990 }
7991 fcp->isp_wwnn_nvram = wwn;
7992
7993 isp_fix_nvram_wwns(isp);
7994
7995 if (ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data)) {
7996 fcp->isp_maxalloc = ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data);
7997 }
7998 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
7999 fcp->isp_maxfrmlen = ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data);
8000 }
8001 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8002 fcp->isp_loopid = ISP2400_NVRAM_HARDLOOPID(nvram_data);
8003 }
8004 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8005 fcp->isp_execthrottle =
8006 ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data);
8007 }
8008 fcp->isp_fwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data);
8009 fcp->isp_xfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data);
8010 fcp->isp_zfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data);
8011}
8012
8013#ifdef ISP_FW_CRASH_DUMP
8014static void isp2200_fw_dump(ispsoftc_t *);
8015static void isp2300_fw_dump(ispsoftc_t *);
8016
8017static void
8018isp2200_fw_dump(ispsoftc_t *isp)
8019{
8020 int i, j;
8021 mbreg_t mbs;
8022 uint16_t *ptr;
8023
8024 MEMZERO(&mbs, sizeof (mbs));
8025 ptr = FCPARAM(isp)->isp_dump_data;
8026 if (ptr == NULL) {
8027 isp_prt(isp, ISP_LOGERR,
8028 "No place to dump RISC registers and SRAM");
8029 return;
8030 }
8031 if (*ptr++) {
8032 isp_prt(isp, ISP_LOGERR,
8033 "dump area for RISC registers and SRAM already used");
8034 return;
8035 }
8036 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
8037 for (i = 0; i < 100; i++) {
8038 USEC_DELAY(100);
8039 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8040 break;
8041 }
8042 }
8043 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8044 /*
8045 * PBIU Registers
8046 */
8047 for (i = 0; i < 8; i++) {
8048 *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1));
8049 }
8050
8051 /*
8052 * Mailbox Registers
8053 */
8054 for (i = 0; i < 8; i++) {
8055 *ptr++ = ISP_READ(isp, MBOX_BLOCK + (i << 1));
8056 }
8057
8058 /*
8059 * DMA Registers
8060 */
8061 for (i = 0; i < 48; i++) {
8062 *ptr++ = ISP_READ(isp, DMA_BLOCK + 0x20 + (i << 1));
8063 }
8064
8065 /*
8066 * RISC H/W Registers
8067 */
8068 ISP_WRITE(isp, BIU2100_CSR, 0);
8069 for (i = 0; i < 16; i++) {
8070 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1));
8071 }
8072
8073 /*
8074 * RISC GP Registers
8075 */
8076 for (j = 0; j < 8; j++) {
8077 ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 8));
8078 for (i = 0; i < 16; i++) {
8079 *ptr++ =
8080 ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8081 }
8082 }
8083
8084 /*
8085 * Frame Buffer Hardware Registers
8086 */
8087 ISP_WRITE(isp, BIU2100_CSR, 0x10);
8088 for (i = 0; i < 16; i++) {
8089 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8090 }
8091
8092 /*
8093 * Fibre Protocol Module 0 Hardware Registers
8094 */
8095 ISP_WRITE(isp, BIU2100_CSR, 0x20);
8096 for (i = 0; i < 64; i++) {
8097 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8098 }
8099
8100 /*
8101 * Fibre Protocol Module 1 Hardware Registers
8102 */
8103 ISP_WRITE(isp, BIU2100_CSR, 0x30);
8104 for (i = 0; i < 64; i++) {
8105 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8106 }
8107 } else {
8108 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause");
8109 return;
8110 }
8111 isp_prt(isp, ISP_LOGALL,
8112 "isp_fw_dump: RISC registers dumped successfully");
8113 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
8114 for (i = 0; i < 100; i++) {
8115 USEC_DELAY(100);
8116 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
8117 break;
8118 }
8119 }
8120 if (ISP_READ(isp, OUTMAILBOX0) != 0) {
8121 isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
8122 return;
8123 }
8124 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
8125 for (i = 0; i < 100; i++) {
8126 USEC_DELAY(100);
8127 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8128 break;
8129 }
8130 }
8131 if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
8132 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause After Reset");
8133 return;
8134 }
8135 ISP_WRITE(isp, RISC_EMB, 0xf2);
8136 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
8137 for (i = 0; i < 100; i++) {
8138 USEC_DELAY(100);
8139 if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
8140 break;
8141 }
8142 }
8143 ISP_ENABLE_INTS(isp);
8144 mbs.param[0] = MBOX_READ_RAM_WORD;
8145 mbs.param[1] = 0x1000;
8146 isp->isp_mbxworkp = (void *) ptr;
8147 isp->isp_mbxwrk0 = 0xefff; /* continuation count */
8148 isp->isp_mbxwrk1 = 0x1001; /* next SRAM address */
8149 isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
8150 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
8151 isp_prt(isp, ISP_LOGWARN,
8152 "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1);
8153 return;
8154 }
8155 ptr = isp->isp_mbxworkp; /* finish fetch of final word */
8156 *ptr++ = isp->isp_mboxtmp[2];
8157 isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully");
8158 FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */
8159 (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
8160}
8161
8162static void
8163isp2300_fw_dump(ispsoftc_t *isp)
8164{
8165 int i, j;
8166 mbreg_t mbs;
8167 uint16_t *ptr;
8168
8169 MEMZERO(&mbs, sizeof (mbs));
8170 ptr = FCPARAM(isp)->isp_dump_data;
8171 if (ptr == NULL) {
8172 isp_prt(isp, ISP_LOGERR,
8173 "No place to dump RISC registers and SRAM");
8174 return;
8175 }
8176 if (*ptr++) {
8177 isp_prt(isp, ISP_LOGERR,
8178 "dump area for RISC registers and SRAM already used");
8179 return;
8180 }
8181 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
8182 for (i = 0; i < 100; i++) {
8183 USEC_DELAY(100);
8184 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8185 break;
8186 }
8187 }
8188 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8189 /*
8190 * PBIU registers
8191 */
8192 for (i = 0; i < 8; i++) {
8193 *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1));
8194 }
8195
8196 /*
8197 * ReqQ-RspQ-Risc2Host Status registers
8198 */
8199 for (i = 0; i < 8; i++) {
8200 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x10 + (i << 1));
8201 }
8202
8203 /*
8204 * Mailbox Registers
8205 */
8206 for (i = 0; i < 32; i++) {
8207 *ptr++ =
8208 ISP_READ(isp, PCI_MBOX_REGS2300_OFF + (i << 1));
8209 }
8210
8211 /*
8212 * Auto Request Response DMA registers
8213 */
8214 ISP_WRITE(isp, BIU2100_CSR, 0x40);
8215 for (i = 0; i < 32; i++) {
8216 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8217 }
8218
8219 /*
8220 * DMA registers
8221 */
8222 ISP_WRITE(isp, BIU2100_CSR, 0x50);
8223 for (i = 0; i < 48; i++) {
8224 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8225 }
8226
8227 /*
8228 * RISC hardware registers
8229 */
8230 ISP_WRITE(isp, BIU2100_CSR, 0);
8231 for (i = 0; i < 16; i++) {
8232 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1));
8233 }
8234
8235 /*
8236 * RISC GP? registers
8237 */
8238 for (j = 0; j < 8; j++) {
8239 ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 9));
8240 for (i = 0; i < 16; i++) {
8241 *ptr++ =
8242 ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8243 }
8244 }
8245
8246 /*
8247 * frame buffer hardware registers
8248 */
8249 ISP_WRITE(isp, BIU2100_CSR, 0x10);
8250 for (i = 0; i < 64; i++) {
8251 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8252 }
8253
8254 /*
8255 * FPM B0 hardware registers
8256 */
8257 ISP_WRITE(isp, BIU2100_CSR, 0x20);
8258 for (i = 0; i < 64; i++) {
8259 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8260 }
8261
8262 /*
8263 * FPM B1 hardware registers
8264 */
8265 ISP_WRITE(isp, BIU2100_CSR, 0x30);
8266 for (i = 0; i < 64; i++) {
8267 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8268 }
8269 } else {
8270 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause");
8271 return;
8272 }
8273 isp_prt(isp, ISP_LOGALL,
8274 "isp_fw_dump: RISC registers dumped successfully");
8275 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
8276 for (i = 0; i < 100; i++) {
8277 USEC_DELAY(100);
8278 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
8279 break;
8280 }
8281 }
8282 if (ISP_READ(isp, OUTMAILBOX0) != 0) {
8283 isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
8284 return;
8285 }
8286 ISP_ENABLE_INTS(isp);
8287 MEMZERO(&mbs, sizeof (mbs));
8288 mbs.param[0] = MBOX_READ_RAM_WORD;
8289 mbs.param[1] = 0x800;
8290 isp->isp_mbxworkp = (void *) ptr;
8291 isp->isp_mbxwrk0 = 0xf7ff; /* continuation count */
8292 isp->isp_mbxwrk1 = 0x801; /* next SRAM address */
8293 isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
8294 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
8295 isp_prt(isp, ISP_LOGWARN,
8296 "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1);
8297 return;
8298 }
8299 ptr = isp->isp_mbxworkp; /* finish fetch of final word */
8300 *ptr++ = isp->isp_mboxtmp[2];
8301 MEMZERO(&mbs, sizeof (mbs));
8302 mbs.param[0] = MBOX_READ_RAM_WORD_EXTENDED;
8303 mbs.param[8] = 1;
8304 isp->isp_mbxworkp = (void *) ptr;
8305 isp->isp_mbxwrk0 = 0xffff; /* continuation count */
8306 isp->isp_mbxwrk1 = 0x1; /* next SRAM address */
8307 isp->isp_mbxwrk8 = 0x1;
8308 isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
8309 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
8310 isp_prt(isp, ISP_LOGWARN,
8311 "RAM DUMP FAILED @ WORD %x", 0x10000 + isp->isp_mbxwrk1);
8312 return;
8313 }
8314 ptr = isp->isp_mbxworkp; /* finish final word */
8315 *ptr++ = mbs.param[2];
8316 isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully");
8317 FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */
8318 (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
8319}
8320
8321void
8322isp_fw_dump(ispsoftc_t *isp)
8323{
8324 if (IS_2200(isp))
8325 isp2200_fw_dump(isp);
8326 else if (IS_23XX(isp))
8327 isp2300_fw_dump(isp);
8328 else if (IS_24XX(isp))
8329 isp_prt(isp, ISP_LOGERR, "24XX dump method undefined");
8330
8331}
8332#endif
| 7513 tmp = ISP_READ(isp, BIU2400_FLASH_DATA);
7514 *rp = tmp;
7515 } else {
7516 *rp = 0xffffffff;
7517 }
7518}
7519
7520static void
7521isp_parse_nvram_1020(ispsoftc_t *isp, uint8_t *nvram_data)
7522{
7523 sdparam *sdp = (sdparam *) isp->isp_param;
7524 int tgt;
7525
7526 sdp->isp_fifo_threshold =
7527 ISP_NVRAM_FIFO_THRESHOLD(nvram_data) |
7528 (ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2);
7529
7530 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7531 sdp->isp_initiator_id =
7532 ISP_NVRAM_INITIATOR_ID(nvram_data);
7533
7534 sdp->isp_bus_reset_delay =
7535 ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
7536
7537 sdp->isp_retry_count =
7538 ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
7539
7540 sdp->isp_retry_delay =
7541 ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
7542
7543 sdp->isp_async_data_setup =
7544 ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
7545
7546 if (isp->isp_type >= ISP_HA_SCSI_1040) {
7547 if (sdp->isp_async_data_setup < 9) {
7548 sdp->isp_async_data_setup = 9;
7549 }
7550 } else {
7551 if (sdp->isp_async_data_setup != 6) {
7552 sdp->isp_async_data_setup = 6;
7553 }
7554 }
7555
7556 sdp->isp_req_ack_active_neg =
7557 ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
7558
7559 sdp->isp_data_line_active_neg =
7560 ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
7561
7562 sdp->isp_data_dma_burst_enabl =
7563 ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
7564
7565 sdp->isp_cmd_dma_burst_enable =
7566 ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
7567
7568 sdp->isp_tag_aging =
7569 ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
7570
7571 sdp->isp_selection_timeout =
7572 ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
7573
7574 sdp->isp_max_queue_depth =
7575 ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
7576
7577 sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
7578
7579 isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
7580 0, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
7581 sdp->isp_bus_reset_delay, sdp->isp_retry_count,
7582 sdp->isp_retry_delay, sdp->isp_async_data_setup);
7583 isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
7584 sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
7585 sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
7586 sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
7587
7588 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7589 sdp->isp_devparam[tgt].dev_enable =
7590 ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt);
7591 sdp->isp_devparam[tgt].exc_throttle =
7592 ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt);
7593 sdp->isp_devparam[tgt].nvrm_offset =
7594 ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt);
7595 sdp->isp_devparam[tgt].nvrm_period =
7596 ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt);
7597 /*
7598 * We probably shouldn't lie about this, but it
7599 * it makes it much safer if we limit NVRAM values
7600 * to sanity.
7601 */
7602 if (isp->isp_type < ISP_HA_SCSI_1040) {
7603 /*
7604 * If we're not ultra, we can't possibly
7605 * be a shorter period than this.
7606 */
7607 if (sdp->isp_devparam[tgt].nvrm_period < 0x19) {
7608 sdp->isp_devparam[tgt].nvrm_period = 0x19;
7609 }
7610 if (sdp->isp_devparam[tgt].nvrm_offset > 0xc) {
7611 sdp->isp_devparam[tgt].nvrm_offset = 0x0c;
7612 }
7613 } else {
7614 if (sdp->isp_devparam[tgt].nvrm_offset > 0x8) {
7615 sdp->isp_devparam[tgt].nvrm_offset = 0x8;
7616 }
7617 }
7618 sdp->isp_devparam[tgt].nvrm_flags = 0;
7619 if (ISP_NVRAM_TGT_RENEG(nvram_data, tgt))
7620 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7621 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7622 if (ISP_NVRAM_TGT_TQING(nvram_data, tgt))
7623 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7624 if (ISP_NVRAM_TGT_SYNC(nvram_data, tgt))
7625 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7626 if (ISP_NVRAM_TGT_WIDE(nvram_data, tgt))
7627 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7628 if (ISP_NVRAM_TGT_PARITY(nvram_data, tgt))
7629 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7630 if (ISP_NVRAM_TGT_DISC(nvram_data, tgt))
7631 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7632 sdp->isp_devparam[tgt].actv_flags = 0; /* we don't know */
7633 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
7634 0, tgt, sdp->isp_devparam[tgt].nvrm_flags,
7635 sdp->isp_devparam[tgt].nvrm_offset,
7636 sdp->isp_devparam[tgt].nvrm_period);
7637 sdp->isp_devparam[tgt].goal_offset =
7638 sdp->isp_devparam[tgt].nvrm_offset;
7639 sdp->isp_devparam[tgt].goal_period =
7640 sdp->isp_devparam[tgt].nvrm_period;
7641 sdp->isp_devparam[tgt].goal_flags =
7642 sdp->isp_devparam[tgt].nvrm_flags;
7643 }
7644}
7645
7646static void
7647isp_parse_nvram_1080(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7648{
7649 sdparam *sdp = (sdparam *) isp->isp_param;
7650 int tgt;
7651
7652 sdp += bus;
7653
7654 sdp->isp_fifo_threshold =
7655 ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data);
7656
7657 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7658 sdp->isp_initiator_id =
7659 ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus);
7660
7661 sdp->isp_bus_reset_delay =
7662 ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7663
7664 sdp->isp_retry_count =
7665 ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7666
7667 sdp->isp_retry_delay =
7668 ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7669
7670 sdp->isp_async_data_setup =
7671 ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7672
7673 sdp->isp_req_ack_active_neg =
7674 ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7675
7676 sdp->isp_data_line_active_neg =
7677 ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7678
7679 sdp->isp_data_dma_burst_enabl =
7680 ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7681
7682 sdp->isp_cmd_dma_burst_enable =
7683 ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7684
7685 sdp->isp_selection_timeout =
7686 ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
7687
7688 sdp->isp_max_queue_depth =
7689 ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
7690
7691 isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
7692 bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
7693 sdp->isp_bus_reset_delay, sdp->isp_retry_count,
7694 sdp->isp_retry_delay, sdp->isp_async_data_setup);
7695 isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
7696 sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
7697 sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
7698 sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
7699
7700
7701 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7702 sdp->isp_devparam[tgt].dev_enable =
7703 ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
7704 sdp->isp_devparam[tgt].exc_throttle =
7705 ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
7706 sdp->isp_devparam[tgt].nvrm_offset =
7707 ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
7708 sdp->isp_devparam[tgt].nvrm_period =
7709 ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
7710 sdp->isp_devparam[tgt].nvrm_flags = 0;
7711 if (ISP1080_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
7712 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7713 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7714 if (ISP1080_NVRAM_TGT_TQING(nvram_data, tgt, bus))
7715 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7716 if (ISP1080_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
7717 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7718 if (ISP1080_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
7719 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7720 if (ISP1080_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
7721 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7722 if (ISP1080_NVRAM_TGT_DISC(nvram_data, tgt, bus))
7723 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7724 sdp->isp_devparam[tgt].actv_flags = 0;
7725 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
7726 bus, tgt, sdp->isp_devparam[tgt].nvrm_flags,
7727 sdp->isp_devparam[tgt].nvrm_offset,
7728 sdp->isp_devparam[tgt].nvrm_period);
7729 sdp->isp_devparam[tgt].goal_offset =
7730 sdp->isp_devparam[tgt].nvrm_offset;
7731 sdp->isp_devparam[tgt].goal_period =
7732 sdp->isp_devparam[tgt].nvrm_period;
7733 sdp->isp_devparam[tgt].goal_flags =
7734 sdp->isp_devparam[tgt].nvrm_flags;
7735 }
7736}
7737
7738static void
7739isp_parse_nvram_12160(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7740{
7741 sdparam *sdp = (sdparam *) isp->isp_param;
7742 int tgt;
7743
7744 sdp += bus;
7745
7746 sdp->isp_fifo_threshold =
7747 ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data);
7748
7749 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7750 sdp->isp_initiator_id =
7751 ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus);
7752
7753 sdp->isp_bus_reset_delay =
7754 ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7755
7756 sdp->isp_retry_count =
7757 ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7758
7759 sdp->isp_retry_delay =
7760 ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7761
7762 sdp->isp_async_data_setup =
7763 ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7764
7765 sdp->isp_req_ack_active_neg =
7766 ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7767
7768 sdp->isp_data_line_active_neg =
7769 ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7770
7771 sdp->isp_data_dma_burst_enabl =
7772 ISP12160_NVRAM_BURST_ENABLE(nvram_data);
7773
7774 sdp->isp_cmd_dma_burst_enable =
7775 ISP12160_NVRAM_BURST_ENABLE(nvram_data);
7776
7777 sdp->isp_selection_timeout =
7778 ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
7779
7780 sdp->isp_max_queue_depth =
7781 ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
7782
7783 isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
7784 bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
7785 sdp->isp_bus_reset_delay, sdp->isp_retry_count,
7786 sdp->isp_retry_delay, sdp->isp_async_data_setup);
7787 isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
7788 sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
7789 sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
7790 sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
7791
7792 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7793 sdp->isp_devparam[tgt].dev_enable =
7794 ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
7795 sdp->isp_devparam[tgt].exc_throttle =
7796 ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
7797 sdp->isp_devparam[tgt].nvrm_offset =
7798 ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
7799 sdp->isp_devparam[tgt].nvrm_period =
7800 ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
7801 sdp->isp_devparam[tgt].nvrm_flags = 0;
7802 if (ISP12160_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
7803 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7804 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7805 if (ISP12160_NVRAM_TGT_TQING(nvram_data, tgt, bus))
7806 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7807 if (ISP12160_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
7808 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7809 if (ISP12160_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
7810 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7811 if (ISP12160_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
7812 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7813 if (ISP12160_NVRAM_TGT_DISC(nvram_data, tgt, bus))
7814 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7815 sdp->isp_devparam[tgt].actv_flags = 0;
7816 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
7817 bus, tgt, sdp->isp_devparam[tgt].nvrm_flags,
7818 sdp->isp_devparam[tgt].nvrm_offset,
7819 sdp->isp_devparam[tgt].nvrm_period);
7820 sdp->isp_devparam[tgt].goal_offset =
7821 sdp->isp_devparam[tgt].nvrm_offset;
7822 sdp->isp_devparam[tgt].goal_period =
7823 sdp->isp_devparam[tgt].nvrm_period;
7824 sdp->isp_devparam[tgt].goal_flags =
7825 sdp->isp_devparam[tgt].nvrm_flags;
7826 }
7827}
7828
7829static void
7830isp_fix_nvram_wwns(ispsoftc_t *isp)
7831{
7832 fcparam *fcp = FCPARAM(isp);
7833
7834 /*
7835 * Make sure we have both Node and Port as non-zero values.
7836 */
7837 if (fcp->isp_wwnn_nvram != 0 && fcp->isp_wwpn_nvram == 0) {
7838 fcp->isp_wwpn_nvram = fcp->isp_wwnn_nvram;
7839 } else if (fcp->isp_wwnn_nvram == 0 && fcp->isp_wwpn_nvram != 0) {
7840 fcp->isp_wwnn_nvram = fcp->isp_wwpn_nvram;
7841 }
7842
7843 /*
7844 * Make the Node and Port values sane if they're NAA == 2.
7845 * This means to clear bits 48..56 for the Node WWN and
7846 * make sure that there's some non-zero value in 48..56
7847 * for the Port WWN.
7848 */
7849 if (fcp->isp_wwnn_nvram && fcp->isp_wwpn_nvram) {
7850 if ((fcp->isp_wwnn_nvram & (((uint64_t) 0xfff) << 48)) != 0 &&
7851 (fcp->isp_wwnn_nvram >> 60) == 2) {
7852 fcp->isp_wwnn_nvram &= ~((uint64_t) 0xfff << 48);
7853 }
7854 if ((fcp->isp_wwpn_nvram & (((uint64_t) 0xfff) << 48)) == 0 &&
7855 (fcp->isp_wwpn_nvram >> 60) == 2) {
7856 fcp->isp_wwpn_nvram |= ((uint64_t) 1 << 56);
7857 }
7858 }
7859}
7860
7861static void
7862isp_parse_nvram_2100(ispsoftc_t *isp, uint8_t *nvram_data)
7863{
7864 fcparam *fcp = FCPARAM(isp);
7865 uint64_t wwn;
7866
7867 /*
7868 * There is NVRAM storage for both Port and Node entities-
7869 * but the Node entity appears to be unused on all the cards
7870 * I can find. However, we should account for this being set
7871 * at some point in the future.
7872 *
7873 * Qlogic WWNs have an NAA of 2, but usually nothing shows up in
7874 * bits 48..60. In the case of the 2202, it appears that they do
7875 * use bit 48 to distinguish between the two instances on the card.
7876 * The 2204, which I've never seen, *probably* extends this method.
7877 */
7878 wwn = ISP2100_NVRAM_PORT_NAME(nvram_data);
7879 if (wwn) {
7880 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
7881 (uint32_t) (wwn >> 32), (uint32_t) (wwn & 0xffffffff));
7882 if ((wwn >> 60) == 0) {
7883 wwn |= (((uint64_t) 2)<< 60);
7884 }
7885 }
7886 fcp->isp_wwpn_nvram = wwn;
7887 if (IS_2200(isp) || IS_23XX(isp)) {
7888 wwn = ISP2100_NVRAM_NODE_NAME(nvram_data);
7889 if (wwn) {
7890 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
7891 (uint32_t) (wwn >> 32),
7892 (uint32_t) (wwn & 0xffffffff));
7893 if ((wwn >> 60) == 0) {
7894 wwn |= (((uint64_t) 2)<< 60);
7895 }
7896 }
7897 } else {
7898 wwn &= ~((uint64_t) 0xfff << 48);
7899 }
7900 fcp->isp_wwnn_nvram = wwn;
7901
7902 isp_fix_nvram_wwns(isp);
7903
7904 fcp->isp_maxalloc = ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
7905 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
7906 fcp->isp_maxfrmlen = ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
7907 }
7908 fcp->isp_retry_delay = ISP2100_NVRAM_RETRY_DELAY(nvram_data);
7909 fcp->isp_retry_count = ISP2100_NVRAM_RETRY_COUNT(nvram_data);
7910 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
7911 fcp->isp_loopid = ISP2100_NVRAM_HARDLOOPID(nvram_data);
7912 }
7913 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
7914 fcp->isp_execthrottle =
7915 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
7916 }
7917 fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
7918 isp_prt(isp, ISP_LOGDEBUG0,
7919 "NVRAM 0x%08x%08x 0x%08x%08x maxalloc %d maxframelen %d",
7920 (uint32_t) (fcp->isp_wwnn_nvram >> 32), (uint32_t) fcp->isp_wwnn_nvram,
7921 (uint32_t) (fcp->isp_wwpn_nvram >> 32), (uint32_t) fcp->isp_wwpn_nvram,
7922 ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data),
7923 ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data));
7924 isp_prt(isp, ISP_LOGDEBUG0,
7925 "execthrottle %d fwoptions 0x%x hardloop %d tov %d",
7926 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data),
7927 ISP2100_NVRAM_OPTIONS(nvram_data),
7928 ISP2100_NVRAM_HARDLOOPID(nvram_data),
7929 ISP2100_NVRAM_TOV(nvram_data));
7930 fcp->isp_xfwoptions = ISP2100_XFW_OPTIONS(nvram_data);
7931 fcp->isp_zfwoptions = ISP2100_ZFW_OPTIONS(nvram_data);
7932 isp_prt(isp, ISP_LOGDEBUG0,
7933 "xfwoptions 0x%x zfw options 0x%x",
7934 ISP2100_XFW_OPTIONS(nvram_data), ISP2100_ZFW_OPTIONS(nvram_data));
7935}
7936
7937static void
7938isp_parse_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
7939{
7940 fcparam *fcp = FCPARAM(isp);
7941 uint64_t wwn;
7942
7943 isp_prt(isp, ISP_LOGDEBUG0,
7944 "NVRAM 0x%08x%08x 0x%08x%08x exchg_cnt %d maxframelen %d",
7945 (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data) >> 32),
7946 (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data)),
7947 (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data) >> 32),
7948 (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data)),
7949 ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data),
7950 ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data));
7951 isp_prt(isp, ISP_LOGDEBUG0,
7952 "NVRAM execthr %d loopid %d fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
7953 ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data),
7954 ISP2400_NVRAM_HARDLOOPID(nvram_data),
7955 ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data),
7956 ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data),
7957 ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data));
7958
7959 wwn = ISP2400_NVRAM_PORT_NAME(nvram_data);
7960 if (wwn) {
7961 if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
7962 wwn = 0;
7963 }
7964 }
7965 fcp->isp_wwpn_nvram = wwn;
7966
7967 wwn = ISP2400_NVRAM_NODE_NAME(nvram_data);
7968 if (wwn) {
7969 if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
7970 wwn = 0;
7971 }
7972 }
7973 fcp->isp_wwnn_nvram = wwn;
7974
7975 isp_fix_nvram_wwns(isp);
7976
7977 if (ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data)) {
7978 fcp->isp_maxalloc = ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data);
7979 }
7980 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
7981 fcp->isp_maxfrmlen = ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data);
7982 }
7983 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
7984 fcp->isp_loopid = ISP2400_NVRAM_HARDLOOPID(nvram_data);
7985 }
7986 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
7987 fcp->isp_execthrottle =
7988 ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data);
7989 }
7990 fcp->isp_fwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data);
7991 fcp->isp_xfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data);
7992 fcp->isp_zfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data);
7993}
7994
7995#ifdef ISP_FW_CRASH_DUMP
7996static void isp2200_fw_dump(ispsoftc_t *);
7997static void isp2300_fw_dump(ispsoftc_t *);
7998
7999static void
8000isp2200_fw_dump(ispsoftc_t *isp)
8001{
8002 int i, j;
8003 mbreg_t mbs;
8004 uint16_t *ptr;
8005
8006 MEMZERO(&mbs, sizeof (mbs));
8007 ptr = FCPARAM(isp)->isp_dump_data;
8008 if (ptr == NULL) {
8009 isp_prt(isp, ISP_LOGERR,
8010 "No place to dump RISC registers and SRAM");
8011 return;
8012 }
8013 if (*ptr++) {
8014 isp_prt(isp, ISP_LOGERR,
8015 "dump area for RISC registers and SRAM already used");
8016 return;
8017 }
8018 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
8019 for (i = 0; i < 100; i++) {
8020 USEC_DELAY(100);
8021 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8022 break;
8023 }
8024 }
8025 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8026 /*
8027 * PBIU Registers
8028 */
8029 for (i = 0; i < 8; i++) {
8030 *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1));
8031 }
8032
8033 /*
8034 * Mailbox Registers
8035 */
8036 for (i = 0; i < 8; i++) {
8037 *ptr++ = ISP_READ(isp, MBOX_BLOCK + (i << 1));
8038 }
8039
8040 /*
8041 * DMA Registers
8042 */
8043 for (i = 0; i < 48; i++) {
8044 *ptr++ = ISP_READ(isp, DMA_BLOCK + 0x20 + (i << 1));
8045 }
8046
8047 /*
8048 * RISC H/W Registers
8049 */
8050 ISP_WRITE(isp, BIU2100_CSR, 0);
8051 for (i = 0; i < 16; i++) {
8052 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1));
8053 }
8054
8055 /*
8056 * RISC GP Registers
8057 */
8058 for (j = 0; j < 8; j++) {
8059 ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 8));
8060 for (i = 0; i < 16; i++) {
8061 *ptr++ =
8062 ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8063 }
8064 }
8065
8066 /*
8067 * Frame Buffer Hardware Registers
8068 */
8069 ISP_WRITE(isp, BIU2100_CSR, 0x10);
8070 for (i = 0; i < 16; i++) {
8071 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8072 }
8073
8074 /*
8075 * Fibre Protocol Module 0 Hardware Registers
8076 */
8077 ISP_WRITE(isp, BIU2100_CSR, 0x20);
8078 for (i = 0; i < 64; i++) {
8079 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8080 }
8081
8082 /*
8083 * Fibre Protocol Module 1 Hardware Registers
8084 */
8085 ISP_WRITE(isp, BIU2100_CSR, 0x30);
8086 for (i = 0; i < 64; i++) {
8087 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8088 }
8089 } else {
8090 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause");
8091 return;
8092 }
8093 isp_prt(isp, ISP_LOGALL,
8094 "isp_fw_dump: RISC registers dumped successfully");
8095 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
8096 for (i = 0; i < 100; i++) {
8097 USEC_DELAY(100);
8098 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
8099 break;
8100 }
8101 }
8102 if (ISP_READ(isp, OUTMAILBOX0) != 0) {
8103 isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
8104 return;
8105 }
8106 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
8107 for (i = 0; i < 100; i++) {
8108 USEC_DELAY(100);
8109 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8110 break;
8111 }
8112 }
8113 if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
8114 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause After Reset");
8115 return;
8116 }
8117 ISP_WRITE(isp, RISC_EMB, 0xf2);
8118 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
8119 for (i = 0; i < 100; i++) {
8120 USEC_DELAY(100);
8121 if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
8122 break;
8123 }
8124 }
8125 ISP_ENABLE_INTS(isp);
8126 mbs.param[0] = MBOX_READ_RAM_WORD;
8127 mbs.param[1] = 0x1000;
8128 isp->isp_mbxworkp = (void *) ptr;
8129 isp->isp_mbxwrk0 = 0xefff; /* continuation count */
8130 isp->isp_mbxwrk1 = 0x1001; /* next SRAM address */
8131 isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
8132 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
8133 isp_prt(isp, ISP_LOGWARN,
8134 "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1);
8135 return;
8136 }
8137 ptr = isp->isp_mbxworkp; /* finish fetch of final word */
8138 *ptr++ = isp->isp_mboxtmp[2];
8139 isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully");
8140 FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */
8141 (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
8142}
8143
8144static void
8145isp2300_fw_dump(ispsoftc_t *isp)
8146{
8147 int i, j;
8148 mbreg_t mbs;
8149 uint16_t *ptr;
8150
8151 MEMZERO(&mbs, sizeof (mbs));
8152 ptr = FCPARAM(isp)->isp_dump_data;
8153 if (ptr == NULL) {
8154 isp_prt(isp, ISP_LOGERR,
8155 "No place to dump RISC registers and SRAM");
8156 return;
8157 }
8158 if (*ptr++) {
8159 isp_prt(isp, ISP_LOGERR,
8160 "dump area for RISC registers and SRAM already used");
8161 return;
8162 }
8163 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
8164 for (i = 0; i < 100; i++) {
8165 USEC_DELAY(100);
8166 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8167 break;
8168 }
8169 }
8170 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8171 /*
8172 * PBIU registers
8173 */
8174 for (i = 0; i < 8; i++) {
8175 *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1));
8176 }
8177
8178 /*
8179 * ReqQ-RspQ-Risc2Host Status registers
8180 */
8181 for (i = 0; i < 8; i++) {
8182 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x10 + (i << 1));
8183 }
8184
8185 /*
8186 * Mailbox Registers
8187 */
8188 for (i = 0; i < 32; i++) {
8189 *ptr++ =
8190 ISP_READ(isp, PCI_MBOX_REGS2300_OFF + (i << 1));
8191 }
8192
8193 /*
8194 * Auto Request Response DMA registers
8195 */
8196 ISP_WRITE(isp, BIU2100_CSR, 0x40);
8197 for (i = 0; i < 32; i++) {
8198 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8199 }
8200
8201 /*
8202 * DMA registers
8203 */
8204 ISP_WRITE(isp, BIU2100_CSR, 0x50);
8205 for (i = 0; i < 48; i++) {
8206 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8207 }
8208
8209 /*
8210 * RISC hardware registers
8211 */
8212 ISP_WRITE(isp, BIU2100_CSR, 0);
8213 for (i = 0; i < 16; i++) {
8214 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1));
8215 }
8216
8217 /*
8218 * RISC GP? registers
8219 */
8220 for (j = 0; j < 8; j++) {
8221 ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 9));
8222 for (i = 0; i < 16; i++) {
8223 *ptr++ =
8224 ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8225 }
8226 }
8227
8228 /*
8229 * frame buffer hardware registers
8230 */
8231 ISP_WRITE(isp, BIU2100_CSR, 0x10);
8232 for (i = 0; i < 64; i++) {
8233 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8234 }
8235
8236 /*
8237 * FPM B0 hardware registers
8238 */
8239 ISP_WRITE(isp, BIU2100_CSR, 0x20);
8240 for (i = 0; i < 64; i++) {
8241 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8242 }
8243
8244 /*
8245 * FPM B1 hardware registers
8246 */
8247 ISP_WRITE(isp, BIU2100_CSR, 0x30);
8248 for (i = 0; i < 64; i++) {
8249 *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8250 }
8251 } else {
8252 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause");
8253 return;
8254 }
8255 isp_prt(isp, ISP_LOGALL,
8256 "isp_fw_dump: RISC registers dumped successfully");
8257 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
8258 for (i = 0; i < 100; i++) {
8259 USEC_DELAY(100);
8260 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
8261 break;
8262 }
8263 }
8264 if (ISP_READ(isp, OUTMAILBOX0) != 0) {
8265 isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
8266 return;
8267 }
8268 ISP_ENABLE_INTS(isp);
8269 MEMZERO(&mbs, sizeof (mbs));
8270 mbs.param[0] = MBOX_READ_RAM_WORD;
8271 mbs.param[1] = 0x800;
8272 isp->isp_mbxworkp = (void *) ptr;
8273 isp->isp_mbxwrk0 = 0xf7ff; /* continuation count */
8274 isp->isp_mbxwrk1 = 0x801; /* next SRAM address */
8275 isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
8276 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
8277 isp_prt(isp, ISP_LOGWARN,
8278 "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1);
8279 return;
8280 }
8281 ptr = isp->isp_mbxworkp; /* finish fetch of final word */
8282 *ptr++ = isp->isp_mboxtmp[2];
8283 MEMZERO(&mbs, sizeof (mbs));
8284 mbs.param[0] = MBOX_READ_RAM_WORD_EXTENDED;
8285 mbs.param[8] = 1;
8286 isp->isp_mbxworkp = (void *) ptr;
8287 isp->isp_mbxwrk0 = 0xffff; /* continuation count */
8288 isp->isp_mbxwrk1 = 0x1; /* next SRAM address */
8289 isp->isp_mbxwrk8 = 0x1;
8290 isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
8291 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
8292 isp_prt(isp, ISP_LOGWARN,
8293 "RAM DUMP FAILED @ WORD %x", 0x10000 + isp->isp_mbxwrk1);
8294 return;
8295 }
8296 ptr = isp->isp_mbxworkp; /* finish final word */
8297 *ptr++ = mbs.param[2];
8298 isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully");
8299 FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */
8300 (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
8301}
8302
8303void
8304isp_fw_dump(ispsoftc_t *isp)
8305{
8306 if (IS_2200(isp))
8307 isp2200_fw_dump(isp);
8308 else if (IS_23XX(isp))
8309 isp2300_fw_dump(isp);
8310 else if (IS_24XX(isp))
8311 isp_prt(isp, ISP_LOGERR, "24XX dump method undefined");
8312
8313}
8314#endif
|