2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2009-2017 Alexander Motin <mav@FreeBSD.org>
5 * Copyright (c) 1997-2009 by Matthew Jacob
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * Machine and OS Independent (well, as best as possible)
34 * code for the Qlogic ISP SCSI and FC-SCSI adapters.
38 * Inspiration and ideas about this driver are from Erik Moe's Linux driver
39 * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
40 * ideas dredged from the Solaris driver.
44 * Include header file appropriate for platform we're building on.
47 #include <sys/cdefs.h>
48 __KERNEL_RCSID(0, "$NetBSD$");
49 #include <dev/ic/isp_netbsd.h>
52 #include <sys/cdefs.h>
53 __FBSDID("$FreeBSD$");
54 #include <dev/isp/isp_freebsd.h>
57 #include <dev/ic/isp_openbsd.h>
60 #include "isp_linux.h"
63 #include "isp_solaris.h"
69 #define MBOX_DELAY_COUNT 1000000 / 100
74 static const char notresp[] = "Unknown IOCB in RESPONSE Queue (type 0x%x) @ idx %d (next %d)";
75 static const char bun[] = "bad underrun (count %d, resid %d, status %s)";
76 static const char lipd[] = "Chan %d LIP destroyed %d active commands";
77 static const char sacq[] = "unable to acquire scratch area";
79 static const uint8_t alpa_map[] = {
80 0xef, 0xe8, 0xe4, 0xe2, 0xe1, 0xe0, 0xdc, 0xda,
81 0xd9, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xce,
82 0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc7, 0xc6, 0xc5,
83 0xc3, 0xbc, 0xba, 0xb9, 0xb6, 0xb5, 0xb4, 0xb3,
84 0xb2, 0xb1, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9,
85 0xa7, 0xa6, 0xa5, 0xa3, 0x9f, 0x9e, 0x9d, 0x9b,
86 0x98, 0x97, 0x90, 0x8f, 0x88, 0x84, 0x82, 0x81,
87 0x80, 0x7c, 0x7a, 0x79, 0x76, 0x75, 0x74, 0x73,
88 0x72, 0x71, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69,
89 0x67, 0x66, 0x65, 0x63, 0x5c, 0x5a, 0x59, 0x56,
90 0x55, 0x54, 0x53, 0x52, 0x51, 0x4e, 0x4d, 0x4c,
91 0x4b, 0x4a, 0x49, 0x47, 0x46, 0x45, 0x43, 0x3c,
92 0x3a, 0x39, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31,
93 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x27, 0x26,
94 0x25, 0x23, 0x1f, 0x1e, 0x1d, 0x1b, 0x18, 0x17,
95 0x10, 0x0f, 0x08, 0x04, 0x02, 0x01, 0x00
99 * Local function prototypes.
101 static void isp_parse_async(ispsoftc_t *, uint16_t);
102 static void isp_parse_async_fc(ispsoftc_t *, uint16_t);
103 static int isp_handle_other_response(ispsoftc_t *, int, isphdr_t *, uint32_t *);
104 static void isp_parse_status(ispsoftc_t *, ispstatusreq_t *, XS_T *, uint32_t *);
105 static void isp_parse_status_24xx(ispsoftc_t *, isp24xx_statusreq_t *, XS_T *, uint32_t *);
106 static void isp_fastpost_complete(ispsoftc_t *, uint32_t);
107 static void isp_scsi_init(ispsoftc_t *);
108 static void isp_scsi_channel_init(ispsoftc_t *, int);
109 static void isp_fibre_init(ispsoftc_t *);
110 static void isp_fibre_init_2400(ispsoftc_t *);
111 static void isp_clear_portdb(ispsoftc_t *, int);
112 static void isp_mark_portdb(ispsoftc_t *, int);
113 static int isp_plogx(ispsoftc_t *, int, uint16_t, uint32_t, int);
114 static int isp_port_login(ispsoftc_t *, uint16_t, uint32_t);
115 static int isp_port_logout(ispsoftc_t *, uint16_t, uint32_t);
116 static int isp_getpdb(ispsoftc_t *, int, uint16_t, isp_pdb_t *);
117 static int isp_gethandles(ispsoftc_t *, int, uint16_t *, int *, int);
118 static void isp_dump_chip_portdb(ispsoftc_t *, int);
119 static uint64_t isp_get_wwn(ispsoftc_t *, int, int, int);
120 static int isp_fclink_test(ispsoftc_t *, int, int);
121 static int isp_pdb_sync(ispsoftc_t *, int);
122 static int isp_scan_loop(ispsoftc_t *, int);
123 static int isp_gid_pt(ispsoftc_t *, int);
124 static int isp_scan_fabric(ispsoftc_t *, int);
125 static int isp_login_device(ispsoftc_t *, int, uint32_t, isp_pdb_t *, uint16_t *);
126 static int isp_send_change_request(ispsoftc_t *, int);
127 static int isp_register_fc4_type(ispsoftc_t *, int);
128 static int isp_register_fc4_features_24xx(ispsoftc_t *, int);
129 static int isp_register_port_name_24xx(ispsoftc_t *, int);
130 static int isp_register_node_name_24xx(ispsoftc_t *, int);
131 static uint16_t isp_next_handle(ispsoftc_t *, uint16_t *);
132 static int isp_fw_state(ispsoftc_t *, int);
133 static void isp_mboxcmd(ispsoftc_t *, mbreg_t *);
135 static void isp_spi_update(ispsoftc_t *, int);
136 static void isp_setdfltsdparm(ispsoftc_t *);
137 static void isp_setdfltfcparm(ispsoftc_t *, int);
138 static int isp_read_nvram(ispsoftc_t *, int);
139 static int isp_read_nvram_2400(ispsoftc_t *, uint8_t *);
140 static void isp_rdnvram_word(ispsoftc_t *, int, uint16_t *);
141 static void isp_rd_2400_nvram(ispsoftc_t *, uint32_t, uint32_t *);
142 static void isp_parse_nvram_1020(ispsoftc_t *, uint8_t *);
143 static void isp_parse_nvram_1080(ispsoftc_t *, int, uint8_t *);
144 static void isp_parse_nvram_12160(ispsoftc_t *, int, uint8_t *);
145 static void isp_parse_nvram_2100(ispsoftc_t *, uint8_t *);
146 static void isp_parse_nvram_2400(ispsoftc_t *, uint8_t *);
149 isp_change_fw_state(ispsoftc_t *isp, int chan, int state)
151 fcparam *fcp = FCPARAM(isp, chan);
153 if (fcp->isp_fwstate == state)
155 isp_prt(isp, ISP_LOGCONFIG|ISP_LOG_SANCFG,
156 "Chan %d Firmware state <%s->%s>", chan,
157 isp_fc_fw_statename(fcp->isp_fwstate), isp_fc_fw_statename(state));
158 fcp->isp_fwstate = state;
164 * Hit the chip over the head, download new f/w if available and set it running.
166 * Locking done elsewhere.
170 isp_reset(ispsoftc_t *isp, int do_load_defaults)
175 uint32_t code_org, val;
176 int loops, i, dodnld = 1;
177 const char *btype = "????";
178 static const char dcrc[] = "Downloaded RISC Code Checksum Failure";
181 * Basic types (SCSI, FibreChannel and PCI or SBus)
182 * have been set in the MD code. We figure out more
183 * here. Possibly more refined types based upon PCI
184 * identification. Chip revision has been gathered.
186 * After we've fired this chip up, zero out the conf1 register
187 * for SCSI adapters and do other settings for the 2100.
190 isp->isp_state = ISP_NILSTATE;
191 ISP_DISABLE_INTS(isp);
194 * Put the board into PAUSE mode (so we can read the SXP registers
195 * or write FPM/FBM registers).
198 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_HOST_INT);
199 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
200 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
202 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
206 switch (isp->isp_type) {
237 * While we're paused, reset the FPM module and FBM
240 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
241 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
242 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
243 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
244 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
246 } else if (IS_1240(isp)) {
251 sdp = SDPARAM(isp, 0);
252 sdp->isp_ultramode = 1;
253 sdp = SDPARAM(isp, 1);
254 sdp->isp_ultramode = 1;
256 * XXX: Should probably do some bus sensing.
258 } else if (IS_ULTRA3(isp)) {
259 sdparam *sdp = isp->isp_param;
261 isp->isp_clock = 100;
265 else if (IS_12160(isp))
269 sdp->isp_lvdmode = 1;
271 if (IS_DUALBUS(isp)) {
273 sdp->isp_lvdmode = 1;
275 } else if (IS_ULTRA2(isp)) {
276 static const char m[] = "bus %d is in %s Mode";
278 sdparam *sdp = SDPARAM(isp, 0);
280 isp->isp_clock = 100;
284 else if (IS_1080(isp))
289 l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
291 case ISP1080_LVD_MODE:
292 sdp->isp_lvdmode = 1;
293 isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
295 case ISP1080_HVD_MODE:
296 sdp->isp_diffmode = 1;
297 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
299 case ISP1080_SE_MODE:
300 sdp->isp_ultramode = 1;
301 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
304 isp_prt(isp, ISP_LOGERR,
305 "unknown mode on bus %d (0x%x)", 0, l);
309 if (IS_DUALBUS(isp)) {
310 sdp = SDPARAM(isp, 1);
311 l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
312 l &= ISP1080_MODE_MASK;
314 case ISP1080_LVD_MODE:
315 sdp->isp_lvdmode = 1;
316 isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
318 case ISP1080_HVD_MODE:
319 sdp->isp_diffmode = 1;
320 isp_prt(isp, ISP_LOGCONFIG,
321 m, 1, "Differential");
323 case ISP1080_SE_MODE:
324 sdp->isp_ultramode = 1;
325 isp_prt(isp, ISP_LOGCONFIG,
326 m, 1, "Single-Ended");
329 isp_prt(isp, ISP_LOGERR,
330 "unknown mode on bus %d (0x%x)", 1, l);
335 sdparam *sdp = SDPARAM(isp, 0);
336 i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
339 isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
343 isp->isp_type = ISP_HA_SCSI_1020;
348 * Some 1020A chips are Ultra Capable, but don't
349 * run the clock rate up for that unless told to
350 * do so by the Ultra Capable bits being set.
353 isp->isp_type = ISP_HA_SCSI_1020A;
358 isp->isp_type = ISP_HA_SCSI_1040;
363 isp->isp_type = ISP_HA_SCSI_1040A;
368 isp->isp_type = ISP_HA_SCSI_1040B;
373 isp->isp_type = ISP_HA_SCSI_1040C;
378 * Now, while we're at it, gather info about ultra
379 * and/or differential mode.
381 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
382 isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
383 sdp->isp_diffmode = 1;
385 sdp->isp_diffmode = 0;
387 i = ISP_READ(isp, RISC_PSR);
388 if (isp->isp_bustype == ISP_BT_SBUS) {
389 i &= RISC_PSR_SBUS_ULTRA;
391 i &= RISC_PSR_PCI_ULTRA;
394 isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
395 sdp->isp_ultramode = 1;
397 * If we're in Ultra Mode, we have to be 60MHz clock-
398 * even for the SBus version.
402 sdp->isp_ultramode = 0;
404 * Clock is known. Gronk.
409 * Machine dependent clock (if set) overrides
410 * our generic determinations.
412 if (isp->isp_mdvec->dv_clock) {
413 if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
414 isp->isp_clock = isp->isp_mdvec->dv_clock;
420 * Hit the chip over the head with hammer,
421 * and give it a chance to recover.
425 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
432 * Clear data && control DMA engines.
434 ISP_WRITE(isp, CDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
435 ISP_WRITE(isp, DDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
438 } else if (IS_24XX(isp)) {
440 * Stop DMA and wait for it to stop.
442 ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
443 for (val = loops = 0; loops < 30000; loops++) {
445 val = ISP_READ(isp, BIU2400_CSR);
446 if ((val & BIU2400_DMA_ACTIVE) == 0) {
450 if (val & BIU2400_DMA_ACTIVE) {
451 isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
455 * Hold it in SOFT_RESET and STOP state for 100us.
457 ISP_WRITE(isp, BIU2400_CSR, BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
459 for (loops = 0; loops < 10000; loops++) {
461 val = ISP_READ(isp, OUTMAILBOX0);
463 for (val = loops = 0; loops < 500000; loops ++) {
464 val = ISP_READ(isp, BIU2400_CSR);
465 if ((val & BIU2400_SOFT_RESET) == 0) {
469 if (val & BIU2400_SOFT_RESET) {
470 isp_prt(isp, ISP_LOGERR, "Failed to come out of reset");
474 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
481 * Clear data && control DMA engines.
483 ISP_WRITE(isp, CDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
484 ISP_WRITE(isp, TDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
485 ISP_WRITE(isp, RDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
489 * Wait for ISP to be ready to go...
491 loops = MBOX_DELAY_COUNT;
494 if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) {
497 } else if (IS_24XX(isp)) {
498 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
502 if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
507 ISP_DUMPREGS(isp, "chip reset timed out");
513 * After we've fired this chip up, zero out the conf1 register
514 * for SCSI adapters and other settings for the 2100.
518 ISP_WRITE(isp, BIU_CONF1, 0);
519 } else if (!IS_24XX(isp)) {
520 ISP_WRITE(isp, BIU2100_CSR, 0);
524 * Reset RISC Processor
527 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
528 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
529 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
531 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
533 ISP_WRITE(isp, BIU_SEMA, 0);
537 * Post-RISC Reset stuff.
540 for (val = loops = 0; loops < 5000000; loops++) {
542 val = ISP_READ(isp, OUTMAILBOX0);
548 isp_prt(isp, ISP_LOGERR, "reset didn't clear");
551 } else if (IS_SCSI(isp)) {
552 uint16_t tmp = isp->isp_mdvec->dv_conf1;
554 * Busted FIFO. Turn off all but burst enables.
556 if (isp->isp_type == ISP_HA_SCSI_1040A) {
557 tmp &= BIU_BURST_ENABLE;
559 ISP_SETBITS(isp, BIU_CONF1, tmp);
560 if (tmp & BIU_BURST_ENABLE) {
561 ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
562 ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
564 if (SDPARAM(isp, 0)->isp_ptisp) {
565 if (SDPARAM(isp, 0)->isp_ultramode) {
566 while (ISP_READ(isp, RISC_MTR) != 0x1313) {
567 ISP_WRITE(isp, RISC_MTR, 0x1313);
568 ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
571 ISP_WRITE(isp, RISC_MTR, 0x1212);
574 * PTI specific register
576 ISP_WRITE(isp, RISC_EMB, DUAL_BANK);
578 ISP_WRITE(isp, RISC_MTR, 0x1212);
580 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
582 ISP_WRITE(isp, RISC_MTR2100, 0x1212);
583 if (IS_2200(isp) || IS_23XX(isp)) {
584 ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
586 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
590 * Set up default request/response queue in-pointer/out-pointer
594 isp->isp_rqstinrp = BIU2400_REQINP;
595 isp->isp_rqstoutrp = BIU2400_REQOUTP;
596 isp->isp_respinrp = BIU2400_RSPINP;
597 isp->isp_respoutrp = BIU2400_RSPOUTP;
598 } else if (IS_23XX(isp)) {
599 isp->isp_rqstinrp = BIU_REQINP;
600 isp->isp_rqstoutrp = BIU_REQOUTP;
601 isp->isp_respinrp = BIU_RSPINP;
602 isp->isp_respoutrp = BIU_RSPOUTP;
604 isp->isp_rqstinrp = INMAILBOX4;
605 isp->isp_rqstoutrp = OUTMAILBOX4;
606 isp->isp_respinrp = OUTMAILBOX5;
607 isp->isp_respoutrp = INMAILBOX5;
609 ISP_WRITE(isp, isp->isp_rqstinrp, 0);
610 ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
611 ISP_WRITE(isp, isp->isp_respinrp, 0);
612 ISP_WRITE(isp, isp->isp_respoutrp, 0);
615 ISP_WRITE(isp, BIU2400_PRI_REQINP, 0);
616 ISP_WRITE(isp, BIU2400_PRI_REQOUTP, 0);
618 ISP_WRITE(isp, BIU2400_ATIO_RSPINP, 0);
619 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, 0);
622 if (!IS_24XX(isp) && isp->isp_bustype == ISP_BT_PCI) {
623 /* Make sure the BIOS is disabled */
624 ISP_WRITE(isp, HCCR, PCI_HCCR_CMD_BIOS);
628 * Wait for everything to finish firing up.
630 * Avoid doing this on early 2312s because you can generate a PCI
631 * parity error (chip breakage).
633 if (IS_2312(isp) && isp->isp_revision < 2) {
636 loops = MBOX_DELAY_COUNT;
637 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
640 isp_prt(isp, ISP_LOGERR, "MBOX_BUSY never cleared on reset");
647 * Up until this point we've done everything by just reading or
648 * setting registers. From this point on we rely on at least *some*
649 * kind of firmware running in the card.
653 * Do some sanity checking by running a NOP command.
654 * If it succeeds, the ROM firmware is now running.
656 MBSINIT(&mbs, MBOX_NO_OP, MBLOGALL, 0);
657 isp_mboxcmd(isp, &mbs);
658 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
659 isp_prt(isp, ISP_LOGERR, "NOP command failed (%x)", mbs.param[0]);
664 * Do some operational tests
666 if (IS_SCSI(isp) || IS_24XX(isp)) {
667 static const uint16_t patterns[MAX_MAILBOX] = {
668 0x0000, 0xdead, 0xbeef, 0xffff,
669 0xa5a5, 0x5a5a, 0x7f7f, 0x7ff7,
670 0x3421, 0xabcd, 0xdcba, 0xfeef,
671 0xbead, 0xdebe, 0x2222, 0x3333,
672 0x5555, 0x6666, 0x7777, 0xaaaa,
673 0xffff, 0xdddd, 0x9999, 0x1fbc,
674 0x6666, 0x6677, 0x1122, 0x33ff,
675 0x0000, 0x0001, 0x1000, 0x1010,
677 int nmbox = ISP_NMBOX(isp);
680 MBSINIT(&mbs, MBOX_MAILBOX_REG_TEST, MBLOGALL, 0);
681 for (i = 1; i < nmbox; i++) {
682 mbs.param[i] = patterns[i];
684 isp_mboxcmd(isp, &mbs);
685 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
688 for (i = 1; i < nmbox; i++) {
689 if (mbs.param[i] != patterns[i]) {
690 isp_prt(isp, ISP_LOGERR, "Register Test Failed at Register %d: should have 0x%04x but got 0x%04x", i, patterns[i], mbs.param[i]);
697 * Download new Firmware, unless requested not to do so.
698 * This is made slightly trickier in some cases where the
699 * firmware of the ROM revision is newer than the revision
700 * compiled into the driver. So, where we used to compare
701 * versions of our f/w and the ROM f/w, now we just see
702 * whether we have f/w at all and whether a config flag
703 * has disabled our download.
705 if ((isp->isp_mdvec->dv_ispfw == NULL) || (isp->isp_confopts & ISP_CFG_NORELOAD)) {
710 * Set up DMA for the request and response queues.
711 * We do this now so we can use the request queue
712 * for dma to load firmware from.
714 if (ISP_MBOXDMASETUP(isp) != 0) {
715 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
721 code_org = ISP_CODE_ORG_2400;
722 } else if (IS_23XX(isp)) {
723 code_org = ISP_CODE_ORG_2300;
725 code_org = ISP_CODE_ORG;
728 isp->isp_loaded_fw = 0;
729 if (dodnld && IS_24XX(isp)) {
730 const uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
734 * Keep loading until we run out of f/w.
736 code_org = ptr[2]; /* 1st load address is our start addr */
740 isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], ptr[2]);
745 while (wi < ptr[3]) {
749 nw = min(wl, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) / 4);
750 cp = isp->isp_rquest;
751 for (i = 0; i < nw; i++)
752 ISP_IOXPUT_32(isp, ptr[wi + i], &cp[i]);
753 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
754 MBSINIT(&mbs, MBOX_LOAD_RISC_RAM, MBLOGALL, 0);
756 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
757 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
758 mbs.param[4] = nw >> 16;
760 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
761 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
762 mbs.param[8] = la >> 16;
763 isp_prt(isp, ISP_LOGDEBUG0, "LOAD RISC RAM %u words at load address 0x%x", nw, la);
764 isp_mboxcmd(isp, &mbs);
765 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
766 isp_prt(isp, ISP_LOGERR, "F/W download failed");
779 isp->isp_loaded_fw = 1;
780 } else if (dodnld && IS_23XX(isp)) {
781 const uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
782 uint16_t wi, wl, segno;
791 isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], la);
796 while (wi < ptr[3]) {
800 nw = min(wl, min((1 << 15), ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) / 2));
801 cp = isp->isp_rquest;
802 for (i = 0; i < nw; i++)
803 ISP_IOXPUT_16(isp, ptr[wi + i], &cp[i]);
804 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
805 MBSINIT(&mbs, 0, MBLOGALL, 0);
807 mbs.param[0] = MBOX_LOAD_RISC_RAM_2100;
809 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
810 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
812 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
813 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
814 isp_prt(isp, ISP_LOGDEBUG1, "LOAD RISC RAM 2100 %u words at load address 0x%x\n", nw, la);
816 mbs.param[0] = MBOX_LOAD_RISC_RAM;
818 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
819 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
821 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
822 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
823 mbs.param[8] = la >> 16;
824 isp_prt(isp, ISP_LOGDEBUG1, "LOAD RISC RAM %u words at load address 0x%x\n", nw, la);
826 isp_mboxcmd(isp, &mbs);
827 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
828 isp_prt(isp, ISP_LOGERR, "F/W download failed");
845 * If we're a 2322, the firmware actually comes in
846 * three chunks. We loaded the first at the code_org
847 * address. The other two chunks, which follow right
848 * after each other in memory here, get loaded at
849 * addresses specfied at offset 0x9..0xB.
854 la = ptr[5] | ((ptr[4] & 0x3f) << 16);
856 isp->isp_loaded_fw = 1;
858 const uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
862 isp_prt(isp, ISP_LOGDEBUG1,
863 "WRITE RAM %u words at load address 0x%x", wl, code_org);
864 for (i = 0; i < wl; i++) {
865 MBSINIT(&mbs, MBOX_WRITE_RAM_WORD, MBLOGNONE, 0);
866 mbs.param[1] = code_org + i;
867 mbs.param[2] = ptr[i];
868 isp_mboxcmd(isp, &mbs);
869 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
870 isp_prt(isp, ISP_LOGERR,
871 "F/W download failed at word %d", i);
875 } else if (IS_26XX(isp)) {
876 MBSINIT(&mbs, MBOX_LOAD_FLASH_FIRMWARE, MBLOGALL, 5000000);
879 isp_mboxcmd(isp, &mbs);
880 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
881 isp_prt(isp, ISP_LOGERR, "Flash F/W load failed");
885 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
889 * If we loaded firmware, verify its checksum
891 if (isp->isp_loaded_fw) {
892 MBSINIT(&mbs, MBOX_VERIFY_CHECKSUM, MBLOGNONE, 0);
894 mbs.param[1] = code_org >> 16;
895 mbs.param[2] = code_org;
897 mbs.param[1] = code_org;
899 isp_mboxcmd(isp, &mbs);
900 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
901 isp_prt(isp, ISP_LOGERR, dcrc);
907 * Now start it rolling.
909 * If we didn't actually download f/w,
910 * we still need to (re)start it.
912 MBSINIT(&mbs, MBOX_EXEC_FIRMWARE, MBLOGALL, 5000000);
914 mbs.param[1] = code_org >> 16;
915 mbs.param[2] = code_org;
916 if (isp->isp_loaded_fw) {
921 } else if (IS_2322(isp)) {
922 mbs.param[1] = code_org;
923 if (isp->isp_loaded_fw) {
929 mbs.param[1] = code_org;
931 isp_mboxcmd(isp, &mbs);
932 if (IS_2322(isp) || IS_24XX(isp)) {
933 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
940 * Set CLOCK RATE, but only if asked to.
942 if (isp->isp_clock) {
943 MBSINIT(&mbs, MBOX_SET_CLOCK_RATE, MBLOGALL, 0);
944 mbs.param[1] = isp->isp_clock;
945 isp_mboxcmd(isp, &mbs);
946 /* we will try not to care if this fails */
951 * Ask the chip for the current firmware version.
952 * This should prove that the new firmware is working.
954 MBSINIT(&mbs, MBOX_ABOUT_FIRMWARE, MBLOGALL, 0);
955 isp_mboxcmd(isp, &mbs);
956 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
961 * The SBus firmware that we are using apparently does not return
962 * major, minor, micro revisions in the mailbox registers, which
963 * is really, really, annoying.
965 if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) {
967 #ifdef ISP_TARGET_MODE
968 isp->isp_fwrev[0] = 7;
969 isp->isp_fwrev[1] = 55;
971 isp->isp_fwrev[0] = 1;
972 isp->isp_fwrev[1] = 37;
974 isp->isp_fwrev[2] = 0;
977 isp->isp_fwrev[0] = mbs.param[1];
978 isp->isp_fwrev[1] = mbs.param[2];
979 isp->isp_fwrev[2] = mbs.param[3];
984 * We do not believe firmware attributes for 2100 code less
985 * than 1.17.0, unless it's the firmware we specifically
988 * Note that all 22XX and later f/w is greater than 1.X.0.
990 if ((ISP_FW_OLDER_THAN(isp, 1, 17, 1))) {
991 #ifdef USE_SMALLER_2100_FIRMWARE
992 isp->isp_fwattr = ISP_FW_ATTR_SCCLUN;
997 isp->isp_fwattr = mbs.param[6];
1000 isp->isp_fwattr |= ((uint64_t) mbs.param[15]) << 16;
1001 if (isp->isp_fwattr & ISP2400_FW_ATTR_EXTNDED) {
1003 (((uint64_t) mbs.param[16]) << 32) |
1004 (((uint64_t) mbs.param[17]) << 48);
1008 isp->isp_fwattr = 0;
1011 isp_prt(isp, ISP_LOGCONFIG, "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
1012 btype, isp->isp_revision, dodnld? "loaded" : "resident", isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
1014 fwt = isp->isp_fwattr;
1016 buf = FCPARAM(isp, 0)->isp_scanscratch;
1017 ISP_SNPRINTF(buf, ISP_FC_SCRLEN, "Attributes:");
1018 if (fwt & ISP2400_FW_ATTR_CLASS2) {
1019 fwt ^=ISP2400_FW_ATTR_CLASS2;
1020 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Class2", buf);
1022 if (fwt & ISP2400_FW_ATTR_IP) {
1023 fwt ^=ISP2400_FW_ATTR_IP;
1024 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s IP", buf);
1026 if (fwt & ISP2400_FW_ATTR_MULTIID) {
1027 fwt ^=ISP2400_FW_ATTR_MULTIID;
1028 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MultiID", buf);
1030 if (fwt & ISP2400_FW_ATTR_SB2) {
1031 fwt ^=ISP2400_FW_ATTR_SB2;
1032 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SB2", buf);
1034 if (fwt & ISP2400_FW_ATTR_T10CRC) {
1035 fwt ^=ISP2400_FW_ATTR_T10CRC;
1036 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s T10CRC", buf);
1038 if (fwt & ISP2400_FW_ATTR_VI) {
1039 fwt ^=ISP2400_FW_ATTR_VI;
1040 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI", buf);
1042 if (fwt & ISP2400_FW_ATTR_MQ) {
1043 fwt ^=ISP2400_FW_ATTR_MQ;
1044 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MQ", buf);
1046 if (fwt & ISP2400_FW_ATTR_MSIX) {
1047 fwt ^=ISP2400_FW_ATTR_MSIX;
1048 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MSIX", buf);
1050 if (fwt & ISP2400_FW_ATTR_FCOE) {
1051 fwt ^=ISP2400_FW_ATTR_FCOE;
1052 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s FCOE", buf);
1054 if (fwt & ISP2400_FW_ATTR_VP0) {
1055 fwt ^= ISP2400_FW_ATTR_VP0;
1056 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VP0_Decoupling", buf);
1058 if (fwt & ISP2400_FW_ATTR_EXPFW) {
1059 fwt ^= ISP2400_FW_ATTR_EXPFW;
1060 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (Experimental)", buf);
1062 if (fwt & ISP2400_FW_ATTR_HOTFW) {
1063 fwt ^= ISP2400_FW_ATTR_HOTFW;
1064 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s HotFW", buf);
1066 fwt &= ~ISP2400_FW_ATTR_EXTNDED;
1067 if (fwt & ISP2400_FW_ATTR_EXTVP) {
1068 fwt ^= ISP2400_FW_ATTR_EXTVP;
1069 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ExtVP", buf);
1071 if (fwt & ISP2400_FW_ATTR_VN2VN) {
1072 fwt ^= ISP2400_FW_ATTR_VN2VN;
1073 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VN2VN", buf);
1075 if (fwt & ISP2400_FW_ATTR_EXMOFF) {
1076 fwt ^= ISP2400_FW_ATTR_EXMOFF;
1077 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s EXMOFF", buf);
1079 if (fwt & ISP2400_FW_ATTR_NPMOFF) {
1080 fwt ^= ISP2400_FW_ATTR_NPMOFF;
1081 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s NPMOFF", buf);
1083 if (fwt & ISP2400_FW_ATTR_DIFCHOP) {
1084 fwt ^= ISP2400_FW_ATTR_DIFCHOP;
1085 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s DIFCHOP", buf);
1087 if (fwt & ISP2400_FW_ATTR_SRIOV) {
1088 fwt ^= ISP2400_FW_ATTR_SRIOV;
1089 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SRIOV", buf);
1091 if (fwt & ISP2400_FW_ATTR_ASICTMP) {
1092 fwt ^= ISP2400_FW_ATTR_ASICTMP;
1093 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ASICTMP", buf);
1095 if (fwt & ISP2400_FW_ATTR_ATIOMQ) {
1096 fwt ^= ISP2400_FW_ATTR_ATIOMQ;
1097 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ATIOMQ", buf);
1100 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (unknown 0x%08x%08x)", buf,
1101 (uint32_t) (fwt >> 32), (uint32_t) fwt);
1103 isp_prt(isp, ISP_LOGCONFIG, "%s", buf);
1104 } else if (IS_FC(isp)) {
1105 buf = FCPARAM(isp, 0)->isp_scanscratch;
1106 ISP_SNPRINTF(buf, ISP_FC_SCRLEN, "Attributes:");
1107 if (fwt & ISP_FW_ATTR_TMODE) {
1108 fwt ^=ISP_FW_ATTR_TMODE;
1109 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s TargetMode", buf);
1111 if (fwt & ISP_FW_ATTR_SCCLUN) {
1112 fwt ^=ISP_FW_ATTR_SCCLUN;
1113 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SCC-Lun", buf);
1115 if (fwt & ISP_FW_ATTR_FABRIC) {
1116 fwt ^=ISP_FW_ATTR_FABRIC;
1117 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Fabric", buf);
1119 if (fwt & ISP_FW_ATTR_CLASS2) {
1120 fwt ^=ISP_FW_ATTR_CLASS2;
1121 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Class2", buf);
1123 if (fwt & ISP_FW_ATTR_FCTAPE) {
1124 fwt ^=ISP_FW_ATTR_FCTAPE;
1125 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s FC-Tape", buf);
1127 if (fwt & ISP_FW_ATTR_IP) {
1128 fwt ^=ISP_FW_ATTR_IP;
1129 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s IP", buf);
1131 if (fwt & ISP_FW_ATTR_VI) {
1132 fwt ^=ISP_FW_ATTR_VI;
1133 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI", buf);
1135 if (fwt & ISP_FW_ATTR_VI_SOLARIS) {
1136 fwt ^=ISP_FW_ATTR_VI_SOLARIS;
1137 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI_SOLARIS", buf);
1139 if (fwt & ISP_FW_ATTR_2KLOGINS) {
1140 fwt ^=ISP_FW_ATTR_2KLOGINS;
1141 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s 2K-Login", buf);
1144 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (unknown 0x%08x%08x)", buf,
1145 (uint32_t) (fwt >> 32), (uint32_t) fwt);
1147 isp_prt(isp, ISP_LOGCONFIG, "%s", buf);
1151 MBSINIT(&mbs, MBOX_GET_RESOURCE_COUNT, MBLOGALL, 0);
1152 isp_mboxcmd(isp, &mbs);
1153 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1156 isp->isp_maxcmds = mbs.param[3];
1158 MBSINIT(&mbs, MBOX_GET_FIRMWARE_STATUS, MBLOGALL, 0);
1159 isp_mboxcmd(isp, &mbs);
1160 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1163 isp->isp_maxcmds = mbs.param[2];
1165 isp_prt(isp, ISP_LOGCONFIG, "%d max I/O command limit set", isp->isp_maxcmds);
1168 * If we don't have Multi-ID f/w loaded, we need to restrict channels to one.
1169 * Only make this check for non-SCSI cards (I'm not sure firmware attributes
1172 if (IS_FC(isp) && isp->isp_nchan > 1) {
1173 if (!ISP_CAP_MULTI_ID(isp)) {
1174 isp_prt(isp, ISP_LOGWARN, "non-MULTIID f/w loaded, "
1175 "only can enable 1 of %d channels", isp->isp_nchan);
1177 } else if (!ISP_CAP_VP0(isp)) {
1178 isp_prt(isp, ISP_LOGWARN, "We can not use MULTIID "
1179 "feature properly without VP0_Decoupling");
1185 * Final DMA setup after we got isp_maxcmds.
1187 if (ISP_MBOXDMASETUP(isp) != 0) {
1188 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
1195 if (ISP_IRQSETUP(isp) != 0) {
1196 isp_prt(isp, ISP_LOGERR, "Cannot setup IRQ");
1199 ISP_ENABLE_INTS(isp);
1202 for (i = 0; i < isp->isp_nchan; i++)
1203 isp_change_fw_state(isp, i, FW_CONFIG_WAIT);
1206 isp->isp_state = ISP_RESETSTATE;
1209 * Okay- now that we have new firmware running, we now (re)set our
1210 * notion of how many luns we support. This is somewhat tricky because
1211 * if we haven't loaded firmware, we sometimes do not have an easy way
1212 * of knowing how many luns we support.
1214 * Expanded lun firmware gives you 32 luns for SCSI cards and
1215 * unlimited luns for Fibre Channel cards.
1217 * It turns out that even for QLogic 2100s with ROM 1.10 and above
1218 * we do get a firmware attributes word returned in mailbox register 6.
1220 * Because the lun is in a different position in the Request Queue
1221 * Entry structure for Fibre Channel with expanded lun firmware, we
1222 * can only support one lun (lun zero) when we don't know what kind
1223 * of firmware we're running.
1227 if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
1228 isp->isp_maxluns = 32;
1230 isp->isp_maxluns = 8;
1233 isp->isp_maxluns = 8;
1236 if (ISP_CAP_SCCFW(isp)) {
1237 isp->isp_maxluns = 0; /* No limit -- 2/8 bytes */
1239 isp->isp_maxluns = 16;
1244 * We get some default values established. As a side
1245 * effect, NVRAM is read here (unless overriden by
1246 * a configuration flag).
1248 if (do_load_defaults) {
1250 isp_setdfltsdparm(isp);
1252 for (i = 0; i < isp->isp_nchan; i++) {
1253 isp_setdfltfcparm(isp, i);
1260 * Clean firmware shutdown.
1263 isp_stop(ispsoftc_t *isp)
1267 isp->isp_state = ISP_NILSTATE;
1268 MBSINIT(&mbs, MBOX_STOP_FIRMWARE, MBLOGALL, 500000);
1277 isp_mboxcmd(isp, &mbs);
1278 return (mbs.param[0] == MBOX_COMMAND_COMPLETE ? 0 : mbs.param[0]);
1282 * Hardware shutdown.
1285 isp_shutdown(ispsoftc_t *isp)
1288 if (isp->isp_state >= ISP_RESETSTATE)
1290 ISP_DISABLE_INTS(isp);
1293 ISP_WRITE(isp, BIU2400_ICR, 0);
1294 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
1296 ISP_WRITE(isp, BIU_ICR, 0);
1297 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
1298 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
1299 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
1300 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
1301 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
1302 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
1305 ISP_WRITE(isp, BIU_ICR, 0);
1306 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
1311 * Initialize Parameters of Hardware to a known state.
1313 * Locks are held before coming here.
1316 isp_init(ispsoftc_t *isp)
1320 isp_fibre_init_2400(isp);
1322 isp_fibre_init(isp);
1330 isp_scsi_init(ispsoftc_t *isp)
1332 sdparam *sdp_chan0, *sdp_chan1;
1335 isp->isp_state = ISP_INITSTATE;
1337 sdp_chan0 = SDPARAM(isp, 0);
1338 sdp_chan1 = sdp_chan0;
1339 if (IS_DUALBUS(isp)) {
1340 sdp_chan1 = SDPARAM(isp, 1);
1343 /* First do overall per-card settings. */
1346 * If we have fast memory timing enabled, turn it on.
1348 if (sdp_chan0->isp_fast_mttr) {
1349 ISP_WRITE(isp, RISC_MTR, 0x1313);
1353 * Set Retry Delay and Count.
1354 * You set both channels at the same time.
1356 MBSINIT(&mbs, MBOX_SET_RETRY_COUNT, MBLOGALL, 0);
1357 mbs.param[1] = sdp_chan0->isp_retry_count;
1358 mbs.param[2] = sdp_chan0->isp_retry_delay;
1359 mbs.param[6] = sdp_chan1->isp_retry_count;
1360 mbs.param[7] = sdp_chan1->isp_retry_delay;
1361 isp_mboxcmd(isp, &mbs);
1362 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1367 * Set ASYNC DATA SETUP time. This is very important.
1369 MBSINIT(&mbs, MBOX_SET_ASYNC_DATA_SETUP_TIME, MBLOGALL, 0);
1370 mbs.param[1] = sdp_chan0->isp_async_data_setup;
1371 mbs.param[2] = sdp_chan1->isp_async_data_setup;
1372 isp_mboxcmd(isp, &mbs);
1373 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1378 * Set ACTIVE Negation State.
1380 MBSINIT(&mbs, MBOX_SET_ACT_NEG_STATE, MBLOGNONE, 0);
1382 (sdp_chan0->isp_req_ack_active_neg << 4) |
1383 (sdp_chan0->isp_data_line_active_neg << 5);
1385 (sdp_chan1->isp_req_ack_active_neg << 4) |
1386 (sdp_chan1->isp_data_line_active_neg << 5);
1387 isp_mboxcmd(isp, &mbs);
1388 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1389 isp_prt(isp, ISP_LOGERR,
1390 "failed to set active negation state (%d,%d), (%d,%d)",
1391 sdp_chan0->isp_req_ack_active_neg,
1392 sdp_chan0->isp_data_line_active_neg,
1393 sdp_chan1->isp_req_ack_active_neg,
1394 sdp_chan1->isp_data_line_active_neg);
1401 * Set the Tag Aging limit
1403 MBSINIT(&mbs, MBOX_SET_TAG_AGE_LIMIT, MBLOGALL, 0);
1404 mbs.param[1] = sdp_chan0->isp_tag_aging;
1405 mbs.param[2] = sdp_chan1->isp_tag_aging;
1406 isp_mboxcmd(isp, &mbs);
1407 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1408 isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
1409 sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
1414 * Set selection timeout.
1416 MBSINIT(&mbs, MBOX_SET_SELECT_TIMEOUT, MBLOGALL, 0);
1417 mbs.param[1] = sdp_chan0->isp_selection_timeout;
1418 mbs.param[2] = sdp_chan1->isp_selection_timeout;
1419 isp_mboxcmd(isp, &mbs);
1420 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1424 /* now do per-channel settings */
1425 isp_scsi_channel_init(isp, 0);
1426 if (IS_DUALBUS(isp))
1427 isp_scsi_channel_init(isp, 1);
1430 * Now enable request/response queues
1433 if (IS_ULTRA2(isp) || IS_1240(isp)) {
1434 MBSINIT(&mbs, MBOX_INIT_RES_QUEUE_A64, MBLOGALL, 0);
1435 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1436 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1437 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1439 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1440 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1441 isp_mboxcmd(isp, &mbs);
1442 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1445 isp->isp_residx = isp->isp_resodx = mbs.param[5];
1447 MBSINIT(&mbs, MBOX_INIT_REQ_QUEUE_A64, MBLOGALL, 0);
1448 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1449 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1450 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1452 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1453 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1454 isp_mboxcmd(isp, &mbs);
1455 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1458 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1460 MBSINIT(&mbs, MBOX_INIT_RES_QUEUE, MBLOGALL, 0);
1461 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1462 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1463 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1465 isp_mboxcmd(isp, &mbs);
1466 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1469 isp->isp_residx = isp->isp_resodx = mbs.param[5];
1471 MBSINIT(&mbs, MBOX_INIT_REQ_QUEUE, MBLOGALL, 0);
1472 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1473 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1474 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1476 isp_mboxcmd(isp, &mbs);
1477 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1480 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1484 * Turn on LVD transitions for ULTRA2 or better and other features
1486 * Now that we have 32 bit handles, don't do any fast posting
1487 * any more. For Ultra2/Ultra3 cards, we can turn on 32 bit RIO
1488 * operation or use fast posting. To be conservative, we'll only
1489 * do this for Ultra3 cards now because the other cards are so
1490 * rare for this author to find and test with.
1493 MBSINIT(&mbs, MBOX_SET_FW_FEATURES, MBLOGALL, 0);
1495 mbs.param[1] |= FW_FEATURE_LVD_NOTIFY;
1498 mbs.param[1] |= FW_FEATURE_FAST_POST;
1501 mbs.param[1] |= FW_FEATURE_RIO_32BIT;
1503 if (mbs.param[1] != 0) {
1504 uint16_t sfeat = mbs.param[1];
1505 isp_mboxcmd(isp, &mbs);
1506 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1507 isp_prt(isp, ISP_LOGINFO,
1508 "Enabled FW features (0x%x)", sfeat);
1512 isp->isp_state = ISP_RUNSTATE;
1516 isp_scsi_channel_init(ispsoftc_t *isp, int chan)
1522 sdp = SDPARAM(isp, chan);
1525 * Set (possibly new) Initiator ID.
1527 MBSINIT(&mbs, MBOX_SET_INIT_SCSI_ID, MBLOGALL, 0);
1528 mbs.param[1] = (chan << 7) | sdp->isp_initiator_id;
1529 isp_mboxcmd(isp, &mbs);
1530 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1533 isp_prt(isp, ISP_LOGINFO, "Chan %d Initiator ID is %d",
1534 chan, sdp->isp_initiator_id);
1538 * Set current per-target parameters to an initial safe minimum.
1540 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1544 if (sdp->isp_devparam[tgt].dev_enable == 0) {
1547 #ifndef ISP_TARGET_MODE
1548 sdf = sdp->isp_devparam[tgt].goal_flags;
1549 sdf &= DPARM_SAFE_DFLT;
1551 * It is not quite clear when this changed over so that
1552 * we could force narrow and async for 1000/1020 cards,
1553 * but assume that this is only the case for loaded
1556 if (isp->isp_loaded_fw) {
1557 sdf |= DPARM_NARROW | DPARM_ASYNC;
1561 * The !$*!)$!$)* f/w uses the same index into some
1562 * internal table to decide how to respond to negotiations,
1563 * so if we've said "let's be safe" for ID X, and ID X
1564 * selects *us*, the negotiations will back to 'safe'
1565 * (as in narrow/async). What the f/w *should* do is
1566 * use the initiator id settings to decide how to respond.
1568 sdp->isp_devparam[tgt].goal_flags = sdf = DPARM_DEFAULT;
1570 MBSINIT(&mbs, MBOX_SET_TARGET_PARAMS, MBLOGNONE, 0);
1571 mbs.param[1] = (chan << 15) | (tgt << 8);
1573 if ((sdf & DPARM_SYNC) == 0) {
1577 (sdp->isp_devparam[tgt].goal_offset << 8) |
1578 (sdp->isp_devparam[tgt].goal_period);
1580 isp_prt(isp, ISP_LOGDEBUG0, "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
1581 chan, tgt, mbs.param[2], mbs.param[3] >> 8, mbs.param[3] & 0xff);
1582 isp_mboxcmd(isp, &mbs);
1583 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1584 sdf = DPARM_SAFE_DFLT;
1585 MBSINIT(&mbs, MBOX_SET_TARGET_PARAMS, MBLOGALL, 0);
1586 mbs.param[1] = (tgt << 8) | (chan << 15);
1589 isp_mboxcmd(isp, &mbs);
1590 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1596 * We don't update any information directly from the f/w
1597 * because we need to run at least one command to cause a
1598 * new state to be latched up. So, we just assume that we
1599 * converge to the values we just had set.
1601 * Ensure that we don't believe tagged queuing is enabled yet.
1602 * It turns out that sometimes the ISP just ignores our
1603 * attempts to set parameters for devices that it hasn't
1606 sdp->isp_devparam[tgt].actv_flags = sdf & ~DPARM_TQING;
1607 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1608 MBSINIT(&mbs, MBOX_SET_DEV_QUEUE_PARAMS, MBLOGALL, 0);
1609 mbs.param[1] = (chan << 15) | (tgt << 8) | lun;
1610 mbs.param[2] = sdp->isp_max_queue_depth;
1611 mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
1612 isp_mboxcmd(isp, &mbs);
1613 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1618 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1619 if (sdp->isp_devparam[tgt].dev_refresh) {
1620 sdp->sendmarker = 1;
1628 * Fibre Channel specific initialization.
1631 isp_fibre_init(ispsoftc_t *isp)
1634 isp_icb_t local, *icbp = &local;
1639 * We only support one channel on non-24XX cards
1641 fcp = FCPARAM(isp, 0);
1642 if (fcp->role == ISP_ROLE_NONE)
1645 isp->isp_state = ISP_INITSTATE;
1646 ISP_MEMZERO(icbp, sizeof (*icbp));
1647 icbp->icb_version = ICB_VERSION1;
1648 icbp->icb_fwoptions = fcp->isp_fwoptions;
1651 * Firmware Options are either retrieved from NVRAM or
1652 * are patched elsewhere. We check them for sanity here
1653 * and make changes based on board revision, but otherwise
1654 * let others decide policy.
1658 * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
1660 if (IS_2100(isp) && isp->isp_revision < 5) {
1661 icbp->icb_fwoptions &= ~ICBOPT_FAIRNESS;
1665 * We have to use FULL LOGIN even though it resets the loop too much
1666 * because otherwise port database entries don't get updated after
1667 * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
1669 if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1670 icbp->icb_fwoptions |= ICBOPT_FULL_LOGIN;
1674 * Insist on Port Database Update Async notifications
1676 icbp->icb_fwoptions |= ICBOPT_PDBCHANGE_AE;
1679 * Make sure that target role reflects into fwoptions.
1681 if (fcp->role & ISP_ROLE_TARGET) {
1682 icbp->icb_fwoptions |= ICBOPT_TGT_ENABLE;
1684 icbp->icb_fwoptions &= ~ICBOPT_TGT_ENABLE;
1688 * For some reason my 2200 does not generate ATIOs in target mode
1689 * if initiator is disabled. Extra logins are better then target
1690 * not working at all.
1692 if ((fcp->role & ISP_ROLE_INITIATOR) || IS_2100(isp) || IS_2200(isp)) {
1693 icbp->icb_fwoptions &= ~ICBOPT_INI_DISABLE;
1695 icbp->icb_fwoptions |= ICBOPT_INI_DISABLE;
1698 icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
1699 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1700 isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
1701 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1703 icbp->icb_maxalloc = fcp->isp_maxalloc;
1704 if (icbp->icb_maxalloc < 1) {
1705 isp_prt(isp, ISP_LOGERR, "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1706 icbp->icb_maxalloc = 16;
1708 icbp->icb_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
1709 if (icbp->icb_execthrottle < 1) {
1710 isp_prt(isp, ISP_LOGERR, "bad execution throttle of %d- using %d", DEFAULT_EXEC_THROTTLE(isp), ICB_DFLT_THROTTLE);
1711 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1713 icbp->icb_retry_delay = fcp->isp_retry_delay;
1714 icbp->icb_retry_count = fcp->isp_retry_count;
1715 icbp->icb_hardaddr = fcp->isp_loopid;
1716 ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
1717 if (icbp->icb_hardaddr >= LOCAL_LOOP_LIM) {
1718 icbp->icb_hardaddr = 0;
1723 * Our life seems so much better with 2200s and later with
1724 * the latest f/w if we set Hard Address.
1726 if (ownloopid || ISP_FW_NEWER_THAN(isp, 2, 2, 5)) {
1727 icbp->icb_fwoptions |= ICBOPT_HARD_ADDRESS;
1731 * Right now we just set extended options to prefer point-to-point
1732 * over loop based upon some soft config options.
1734 * NB: for the 2300, ICBOPT_EXTENDED is required.
1738 * We can't have Fast Posting any more- we now
1739 * have 32 bit handles.
1741 icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1742 } else if (IS_2200(isp) || IS_23XX(isp)) {
1743 icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1745 icbp->icb_xfwoptions = fcp->isp_xfwoptions;
1747 if (ISP_CAP_FCTAPE(isp)) {
1748 if (isp->isp_confopts & ISP_CFG_NOFCTAPE)
1749 icbp->icb_xfwoptions &= ~ICBXOPT_FCTAPE;
1751 if (isp->isp_confopts & ISP_CFG_FCTAPE)
1752 icbp->icb_xfwoptions |= ICBXOPT_FCTAPE;
1754 if (icbp->icb_xfwoptions & ICBXOPT_FCTAPE) {
1755 icbp->icb_fwoptions &= ~ICBOPT_FULL_LOGIN; /* per documents */
1756 icbp->icb_xfwoptions |= ICBXOPT_FCTAPE_CCQ|ICBXOPT_FCTAPE_CONFIRM;
1757 FCPARAM(isp, 0)->fctape_enabled = 1;
1759 FCPARAM(isp, 0)->fctape_enabled = 0;
1762 icbp->icb_xfwoptions &= ~ICBXOPT_FCTAPE;
1763 FCPARAM(isp, 0)->fctape_enabled = 0;
1767 * Prefer or force Point-To-Point instead Loop?
1769 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
1770 case ISP_CFG_LPORT_ONLY:
1771 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1772 icbp->icb_xfwoptions |= ICBXOPT_LOOP_ONLY;
1774 case ISP_CFG_NPORT_ONLY:
1775 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1776 icbp->icb_xfwoptions |= ICBXOPT_PTP_ONLY;
1779 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1780 icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1783 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1784 icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
1787 /* Let NVRAM settings define it if they are sane */
1788 switch (icbp->icb_xfwoptions & ICBXOPT_TOPO_MASK) {
1789 case ICBXOPT_PTP_2_LOOP:
1790 case ICBXOPT_PTP_ONLY:
1791 case ICBXOPT_LOOP_ONLY:
1792 case ICBXOPT_LOOP_2_PTP:
1795 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1796 icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1802 * We can't have Fast Posting any more- we now
1803 * have 32 bit handles.
1805 * RIO seemed to have to much breakage.
1807 * Just opt for safety.
1809 icbp->icb_xfwoptions &= ~ICBXOPT_RIO_16BIT;
1810 icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1813 * QLogic recommends that FAST Posting be turned
1814 * off for 23XX cards and instead allow the HBA
1815 * to write response queue entries and interrupt
1816 * after a delay (ZIO).
1818 icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1819 if ((fcp->isp_xfwoptions & ICBXOPT_TIMER_MASK) == ICBXOPT_ZIO) {
1820 icbp->icb_xfwoptions |= ICBXOPT_ZIO;
1821 icbp->icb_idelaytimer = 10;
1823 icbp->icb_zfwoptions = fcp->isp_zfwoptions;
1824 if (isp->isp_confopts & ISP_CFG_1GB) {
1825 icbp->icb_zfwoptions &= ~ICBZOPT_RATE_MASK;
1826 icbp->icb_zfwoptions |= ICBZOPT_RATE_1GB;
1827 } else if (isp->isp_confopts & ISP_CFG_2GB) {
1828 icbp->icb_zfwoptions &= ~ICBZOPT_RATE_MASK;
1829 icbp->icb_zfwoptions |= ICBZOPT_RATE_2GB;
1831 switch (icbp->icb_zfwoptions & ICBZOPT_RATE_MASK) {
1832 case ICBZOPT_RATE_1GB:
1833 case ICBZOPT_RATE_2GB:
1834 case ICBZOPT_RATE_AUTO:
1837 icbp->icb_zfwoptions &= ~ICBZOPT_RATE_MASK;
1838 icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO;
1847 * For 22XX > 2.1.26 && 23XX, set some options.
1849 if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1850 MBSINIT(&mbs, MBOX_SET_FIRMWARE_OPTIONS, MBLOGALL, 0);
1851 mbs.param[1] = IFCOPT1_DISF7SWTCH|IFCOPT1_LIPASYNC|IFCOPT1_LIPF8;
1854 if (ISP_FW_NEWER_THAN(isp, 3, 16, 0)) {
1855 mbs.param[1] |= IFCOPT1_EQFQASYNC|IFCOPT1_CTIO_RETRY;
1856 if (fcp->role & ISP_ROLE_TARGET) {
1857 if (ISP_FW_NEWER_THAN(isp, 3, 25, 0)) {
1858 mbs.param[1] |= IFCOPT1_ENAPURE;
1860 mbs.param[3] = IFCOPT3_NOPRLI;
1863 isp_mboxcmd(isp, &mbs);
1864 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1868 icbp->icb_logintime = ICB_LOGIN_TOV;
1870 #ifdef ISP_TARGET_MODE
1871 if (icbp->icb_fwoptions & ICBOPT_TGT_ENABLE) {
1872 icbp->icb_lunenables = 0xffff;
1873 icbp->icb_ccnt = 0xff;
1874 icbp->icb_icnt = 0xff;
1875 icbp->icb_lunetimeout = ICB_LUN_ENABLE_TOV;
1878 if (fcp->isp_wwnn && fcp->isp_wwpn) {
1879 icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
1880 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwnn);
1881 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
1882 isp_prt(isp, ISP_LOGDEBUG1,
1883 "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1884 ((uint32_t) (fcp->isp_wwnn >> 32)),
1885 ((uint32_t) (fcp->isp_wwnn)),
1886 ((uint32_t) (fcp->isp_wwpn >> 32)),
1887 ((uint32_t) (fcp->isp_wwpn)));
1888 } else if (fcp->isp_wwpn) {
1889 icbp->icb_fwoptions &= ~ICBOPT_BOTH_WWNS;
1890 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
1891 isp_prt(isp, ISP_LOGDEBUG1,
1892 "Setting ICB Port 0x%08x%08x",
1893 ((uint32_t) (fcp->isp_wwpn >> 32)),
1894 ((uint32_t) (fcp->isp_wwpn)));
1896 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1899 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1900 if (icbp->icb_rqstqlen < 1) {
1901 isp_prt(isp, ISP_LOGERR, "bad request queue length");
1903 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1904 if (icbp->icb_rsltqlen < 1) {
1905 isp_prt(isp, ISP_LOGERR, "bad result queue length");
1907 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1908 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1909 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1910 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1911 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1912 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1913 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1914 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1916 if (FC_SCRATCH_ACQUIRE(isp, 0)) {
1917 isp_prt(isp, ISP_LOGERR, sacq);
1920 isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
1921 icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions);
1923 isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
1924 if (isp->isp_dblev & ISP_LOGDEBUG1) {
1925 isp_print_bytes(isp, "isp_fibre_init",
1926 sizeof(*icbp), fcp->isp_scratch);
1932 MBSINIT(&mbs, MBOX_INIT_FIRMWARE, MBLOGALL, 30000000);
1934 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1935 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1936 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1937 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1938 isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %p (%08x%08x)",
1939 fcp->isp_scratch, (uint32_t) ((uint64_t)fcp->isp_scdma >> 32),
1940 (uint32_t) fcp->isp_scdma);
1941 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
1942 isp_mboxcmd(isp, &mbs);
1943 FC_SCRATCH_RELEASE(isp, 0);
1944 if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
1946 isp->isp_reqidx = 0;
1947 isp->isp_reqodx = 0;
1948 isp->isp_residx = 0;
1949 isp->isp_resodx = 0;
1952 * Whatever happens, we're now committed to being here.
1954 isp->isp_state = ISP_RUNSTATE;
1958 isp_fibre_init_2400(ispsoftc_t *isp)
1961 isp_icb_2400_t local, *icbp = &local;
1967 * Check to see whether all channels have *some* kind of role
1969 for (chan = 0; chan < isp->isp_nchan; chan++) {
1970 fcp = FCPARAM(isp, chan);
1971 if (fcp->role != ISP_ROLE_NONE) {
1975 if (chan == isp->isp_nchan) {
1976 isp_prt(isp, ISP_LOG_WARN1, "all %d channels with role 'none'", chan);
1980 isp->isp_state = ISP_INITSTATE;
1983 * Start with channel 0.
1985 fcp = FCPARAM(isp, 0);
1988 * Turn on LIP F8 async event (1)
1990 MBSINIT(&mbs, MBOX_SET_FIRMWARE_OPTIONS, MBLOGALL, 0);
1992 isp_mboxcmd(isp, &mbs);
1993 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1997 ISP_MEMZERO(icbp, sizeof (*icbp));
1998 icbp->icb_fwoptions1 = fcp->isp_fwoptions;
1999 icbp->icb_fwoptions2 = fcp->isp_xfwoptions;
2000 icbp->icb_fwoptions3 = fcp->isp_zfwoptions;
2001 if (isp->isp_nchan > 1 && ISP_CAP_VP0(isp)) {
2002 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_INI_DISABLE;
2003 icbp->icb_fwoptions1 |= ICB2400_OPT1_TGT_ENABLE;
2005 if (fcp->role & ISP_ROLE_TARGET)
2006 icbp->icb_fwoptions1 |= ICB2400_OPT1_TGT_ENABLE;
2008 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_TGT_ENABLE;
2009 if (fcp->role & ISP_ROLE_INITIATOR)
2010 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_INI_DISABLE;
2012 icbp->icb_fwoptions1 |= ICB2400_OPT1_INI_DISABLE;
2015 icbp->icb_version = ICB_VERSION1;
2016 icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
2017 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
2018 isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
2019 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
2022 icbp->icb_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
2023 if (icbp->icb_execthrottle < 1) {
2024 isp_prt(isp, ISP_LOGERR, "bad execution throttle of %d- using %d", DEFAULT_EXEC_THROTTLE(isp), ICB_DFLT_THROTTLE);
2025 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
2029 * Set target exchange count. Take half if we are supporting both roles.
2031 if (icbp->icb_fwoptions1 & ICB2400_OPT1_TGT_ENABLE) {
2032 icbp->icb_xchgcnt = isp->isp_maxcmds;
2033 if ((icbp->icb_fwoptions1 & ICB2400_OPT1_INI_DISABLE) == 0)
2034 icbp->icb_xchgcnt >>= 1;
2038 ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
2039 icbp->icb_hardaddr = fcp->isp_loopid;
2040 if (icbp->icb_hardaddr >= LOCAL_LOOP_LIM) {
2041 icbp->icb_hardaddr = 0;
2046 icbp->icb_fwoptions1 |= ICB2400_OPT1_HARD_ADDRESS;
2048 if (isp->isp_confopts & ISP_CFG_NOFCTAPE) {
2049 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_FCTAPE;
2051 if (isp->isp_confopts & ISP_CFG_FCTAPE) {
2052 icbp->icb_fwoptions2 |= ICB2400_OPT2_FCTAPE;
2055 for (chan = 0; chan < isp->isp_nchan; chan++) {
2056 if (icbp->icb_fwoptions2 & ICB2400_OPT2_FCTAPE)
2057 FCPARAM(isp, chan)->fctape_enabled = 1;
2059 FCPARAM(isp, chan)->fctape_enabled = 0;
2062 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
2063 case ISP_CFG_LPORT_ONLY:
2064 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2065 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_ONLY;
2067 case ISP_CFG_NPORT_ONLY:
2068 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2069 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_ONLY;
2072 /* ISP_CFG_PTP_2_LOOP not available in 24XX/25XX */
2074 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2075 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
2078 /* Let NVRAM settings define it if they are sane */
2079 switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TOPO_MASK) {
2080 case ICB2400_OPT2_LOOP_ONLY:
2081 case ICB2400_OPT2_PTP_ONLY:
2082 case ICB2400_OPT2_LOOP_2_PTP:
2085 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2086 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
2091 switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK) {
2092 case ICB2400_OPT2_ZIO:
2093 case ICB2400_OPT2_ZIO1:
2094 icbp->icb_idelaytimer = 0;
2099 isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field", icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
2100 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TIMER_MASK;
2105 /* Use handshake to reduce global lock congestion. */
2106 icbp->icb_fwoptions2 |= ICB2400_OPT2_ENA_IHR;
2107 icbp->icb_fwoptions2 |= ICB2400_OPT2_ENA_IHA;
2110 if ((icbp->icb_fwoptions3 & ICB2400_OPT3_RSPSZ_MASK) == 0) {
2111 icbp->icb_fwoptions3 |= ICB2400_OPT3_RSPSZ_24;
2113 if (isp->isp_confopts & ISP_CFG_1GB) {
2114 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2115 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_1GB;
2116 } else if (isp->isp_confopts & ISP_CFG_2GB) {
2117 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2118 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_2GB;
2119 } else if (isp->isp_confopts & ISP_CFG_4GB) {
2120 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2121 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_4GB;
2122 } else if (isp->isp_confopts & ISP_CFG_8GB) {
2123 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2124 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_8GB;
2125 } else if (isp->isp_confopts & ISP_CFG_16GB) {
2126 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2127 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_16GB;
2129 switch (icbp->icb_fwoptions3 & ICB2400_OPT3_RATE_MASK) {
2130 case ICB2400_OPT3_RATE_4GB:
2131 case ICB2400_OPT3_RATE_8GB:
2132 case ICB2400_OPT3_RATE_16GB:
2133 case ICB2400_OPT3_RATE_AUTO:
2135 case ICB2400_OPT3_RATE_2GB:
2136 if (isp->isp_type <= ISP_HA_FC_2500)
2139 case ICB2400_OPT3_RATE_1GB:
2140 if (isp->isp_type <= ISP_HA_FC_2400)
2144 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2145 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_AUTO;
2149 if (ownloopid == 0) {
2150 icbp->icb_fwoptions3 |= ICB2400_OPT3_SOFTID;
2152 icbp->icb_logintime = ICB_LOGIN_TOV;
2154 if (fcp->isp_wwnn && fcp->isp_wwpn) {
2155 icbp->icb_fwoptions1 |= ICB2400_OPT1_BOTH_WWNS;
2156 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
2157 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwnn);
2158 isp_prt(isp, ISP_LOGDEBUG1, "Setting ICB Node 0x%08x%08x Port 0x%08x%08x", ((uint32_t) (fcp->isp_wwnn >> 32)), ((uint32_t) (fcp->isp_wwnn)),
2159 ((uint32_t) (fcp->isp_wwpn >> 32)), ((uint32_t) (fcp->isp_wwpn)));
2160 } else if (fcp->isp_wwpn) {
2161 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_BOTH_WWNS;
2162 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
2163 isp_prt(isp, ISP_LOGDEBUG1, "Setting ICB Node to be same as Port 0x%08x%08x", ((uint32_t) (fcp->isp_wwpn >> 32)), ((uint32_t) (fcp->isp_wwpn)));
2165 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
2168 icbp->icb_retry_count = fcp->isp_retry_count;
2170 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
2171 if (icbp->icb_rqstqlen < 8) {
2172 isp_prt(isp, ISP_LOGERR, "bad request queue length %d", icbp->icb_rqstqlen);
2175 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
2176 if (icbp->icb_rsltqlen < 8) {
2177 isp_prt(isp, ISP_LOGERR, "bad result queue length %d",
2178 icbp->icb_rsltqlen);
2181 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
2182 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
2183 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
2184 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
2186 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
2187 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
2188 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
2189 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
2191 #ifdef ISP_TARGET_MODE
2192 /* unconditionally set up the ATIO queue if we support target mode */
2193 icbp->icb_atioqlen = RESULT_QUEUE_LEN(isp);
2194 if (icbp->icb_atioqlen < 8) {
2195 isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d", icbp->icb_atioqlen);
2198 icbp->icb_atioqaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_atioq_dma);
2199 icbp->icb_atioqaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_atioq_dma);
2200 icbp->icb_atioqaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_atioq_dma);
2201 icbp->icb_atioqaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_atioq_dma);
2202 isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init_2400: atioq %04x%04x%04x%04x", DMA_WD3(isp->isp_atioq_dma), DMA_WD2(isp->isp_atioq_dma),
2203 DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
2206 if (ISP_CAP_MSIX(isp) && isp->isp_nirq >= 2) {
2207 icbp->icb_msixresp = 1;
2208 if (IS_26XX(isp) && isp->isp_nirq >= 3)
2209 icbp->icb_msixatio = 2;
2212 isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init_2400: fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x", icbp->icb_fwoptions1, icbp->icb_fwoptions2, icbp->icb_fwoptions3);
2214 isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init_2400: rqst %04x%04x%04x%04x rsp %04x%04x%04x%04x", DMA_WD3(isp->isp_rquest_dma), DMA_WD2(isp->isp_rquest_dma),
2215 DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma), DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
2216 DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
2218 if (FC_SCRATCH_ACQUIRE(isp, 0)) {
2219 isp_prt(isp, ISP_LOGERR, sacq);
2222 ISP_MEMZERO(fcp->isp_scratch, ISP_FC_SCRLEN);
2223 isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
2224 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2225 isp_print_bytes(isp, "isp_fibre_init_2400",
2226 sizeof (*icbp), fcp->isp_scratch);
2230 * Now fill in information about any additional channels
2232 if (isp->isp_nchan > 1) {
2233 isp_icb_2400_vpinfo_t vpinfo, *vdst;
2234 vp_port_info_t pi, *pdst;
2238 vpinfo.vp_global_options = ICB2400_VPGOPT_GEN_RIDA;
2239 if (ISP_CAP_VP0(isp)) {
2240 vpinfo.vp_global_options |= ICB2400_VPGOPT_VP0_DECOUPLE;
2241 vpinfo.vp_count = isp->isp_nchan;
2244 vpinfo.vp_count = isp->isp_nchan - 1;
2247 off = fcp->isp_scratch;
2248 off += ICB2400_VPINFO_OFF;
2249 vdst = (isp_icb_2400_vpinfo_t *) off;
2250 isp_put_icb_2400_vpinfo(isp, &vpinfo, vdst);
2251 amt = ICB2400_VPINFO_OFF + sizeof (isp_icb_2400_vpinfo_t);
2252 for (; chan < isp->isp_nchan; chan++) {
2255 ISP_MEMZERO(&pi, sizeof (pi));
2256 fcp2 = FCPARAM(isp, chan);
2257 if (fcp2->role != ISP_ROLE_NONE) {
2258 pi.vp_port_options = ICB2400_VPOPT_ENABLED |
2259 ICB2400_VPOPT_ENA_SNSLOGIN;
2260 if (fcp2->role & ISP_ROLE_INITIATOR)
2261 pi.vp_port_options |= ICB2400_VPOPT_INI_ENABLE;
2262 if ((fcp2->role & ISP_ROLE_TARGET) == 0)
2263 pi.vp_port_options |= ICB2400_VPOPT_TGT_DISABLE;
2264 if (fcp2->isp_loopid < LOCAL_LOOP_LIM) {
2265 pi.vp_port_loopid = fcp2->isp_loopid;
2266 if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
2267 pi.vp_port_options |= ICB2400_VPOPT_HARD_ADDRESS;
2271 MAKE_NODE_NAME_FROM_WWN(pi.vp_port_portname, fcp2->isp_wwpn);
2272 MAKE_NODE_NAME_FROM_WWN(pi.vp_port_nodename, fcp2->isp_wwnn);
2273 off = fcp->isp_scratch;
2274 if (ISP_CAP_VP0(isp))
2275 off += ICB2400_VPINFO_PORT_OFF(chan);
2277 off += ICB2400_VPINFO_PORT_OFF(chan - 1);
2278 pdst = (vp_port_info_t *) off;
2279 isp_put_vp_port_info(isp, &pi, pdst);
2280 amt += ICB2400_VPOPT_WRITE_SIZE;
2282 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2283 isp_print_bytes(isp, "isp_fibre_init_2400",
2284 amt - ICB2400_VPINFO_OFF,
2285 (char *)fcp->isp_scratch + ICB2400_VPINFO_OFF);
2292 MBSINIT(&mbs, 0, MBLOGALL, 30000000);
2293 if (isp->isp_nchan > 1) {
2294 mbs.param[0] = MBOX_INIT_FIRMWARE_MULTI_ID;
2296 mbs.param[0] = MBOX_INIT_FIRMWARE;
2299 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2300 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2301 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2302 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2303 isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %04x%04x%04x%04x", DMA_WD3(fcp->isp_scdma), DMA_WD2(fcp->isp_scdma), DMA_WD1(fcp->isp_scdma), DMA_WD0(fcp->isp_scdma));
2304 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
2305 isp_mboxcmd(isp, &mbs);
2306 FC_SCRATCH_RELEASE(isp, 0);
2308 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2311 isp->isp_reqidx = 0;
2312 isp->isp_reqodx = 0;
2313 isp->isp_residx = 0;
2314 isp->isp_resodx = 0;
2315 isp->isp_atioodx = 0;
2318 * Whatever happens, we're now committed to being here.
2320 isp->isp_state = ISP_RUNSTATE;
2324 isp_fc_enable_vp(ispsoftc_t *isp, int chan)
2326 fcparam *fcp = FCPARAM(isp, chan);
2329 uint8_t resp[QENTRY_LEN];
2331 /* Build a VP MODIFY command in memory */
2332 ISP_MEMZERO(&vp, sizeof(vp));
2333 vp.vp_mod_hdr.rqs_entry_type = RQSTYPE_VP_MODIFY;
2334 vp.vp_mod_hdr.rqs_entry_count = 1;
2336 vp.vp_mod_idx0 = chan;
2337 vp.vp_mod_cmd = VP_MODIFY_ENA;
2338 vp.vp_mod_ports[0].options = ICB2400_VPOPT_ENABLED |
2339 ICB2400_VPOPT_ENA_SNSLOGIN;
2340 if (fcp->role & ISP_ROLE_INITIATOR)
2341 vp.vp_mod_ports[0].options |= ICB2400_VPOPT_INI_ENABLE;
2342 if ((fcp->role & ISP_ROLE_TARGET) == 0)
2343 vp.vp_mod_ports[0].options |= ICB2400_VPOPT_TGT_DISABLE;
2344 if (fcp->isp_loopid < LOCAL_LOOP_LIM) {
2345 vp.vp_mod_ports[0].loopid = fcp->isp_loopid;
2346 if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
2347 vp.vp_mod_ports[0].options |= ICB2400_VPOPT_HARD_ADDRESS;
2349 MAKE_NODE_NAME_FROM_WWN(vp.vp_mod_ports[0].wwpn, fcp->isp_wwpn);
2350 MAKE_NODE_NAME_FROM_WWN(vp.vp_mod_ports[0].wwnn, fcp->isp_wwnn);
2352 /* Prepare space for response in memory */
2353 memset(resp, 0xff, sizeof(resp));
2354 vp.vp_mod_hdl = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2355 if (vp.vp_mod_hdl == 0) {
2356 isp_prt(isp, ISP_LOGERR,
2357 "%s: VP_MODIFY of Chan %d out of handles", __func__, chan);
2361 /* Send request and wait for response. */
2362 reqp = isp_getrqentry(isp);
2364 isp_prt(isp, ISP_LOGERR,
2365 "%s: VP_MODIFY of Chan %d out of rqent", __func__, chan);
2366 isp_destroy_handle(isp, vp.vp_mod_hdl);
2369 isp_put_vp_modify(isp, &vp, (vp_modify_t *)reqp);
2370 if (isp->isp_dblev & ISP_LOGDEBUG1)
2371 isp_print_bytes(isp, "IOCB VP_MODIFY", QENTRY_LEN, reqp);
2372 ISP_SYNC_REQUEST(isp);
2373 if (msleep(resp, &isp->isp_lock, 0, "VP_MODIFY", 5*hz) == EWOULDBLOCK) {
2374 isp_prt(isp, ISP_LOGERR,
2375 "%s: VP_MODIFY of Chan %d timed out", __func__, chan);
2376 isp_destroy_handle(isp, vp.vp_mod_hdl);
2379 if (isp->isp_dblev & ISP_LOGDEBUG1)
2380 isp_print_bytes(isp, "IOCB VP_MODIFY response", QENTRY_LEN, resp);
2381 isp_get_vp_modify(isp, (vp_modify_t *)resp, &vp);
2383 if (vp.vp_mod_hdr.rqs_flags != 0 || vp.vp_mod_status != VP_STS_OK) {
2384 isp_prt(isp, ISP_LOGERR,
2385 "%s: VP_MODIFY of Chan %d failed with flags %x status %d",
2386 __func__, chan, vp.vp_mod_hdr.rqs_flags, vp.vp_mod_status);
2393 isp_fc_disable_vp(ispsoftc_t *isp, int chan)
2397 uint8_t resp[QENTRY_LEN];
2399 /* Build a VP CTRL command in memory */
2400 ISP_MEMZERO(&vp, sizeof(vp));
2401 vp.vp_ctrl_hdr.rqs_entry_type = RQSTYPE_VP_CTRL;
2402 vp.vp_ctrl_hdr.rqs_entry_count = 1;
2403 if (ISP_CAP_VP0(isp)) {
2404 vp.vp_ctrl_status = 1;
2406 vp.vp_ctrl_status = 0;
2407 chan--; /* VP0 can not be controlled in this case. */
2409 vp.vp_ctrl_command = VP_CTRL_CMD_DISABLE_VP_LOGO_ALL;
2410 vp.vp_ctrl_vp_count = 1;
2411 vp.vp_ctrl_idmap[chan / 16] |= (1 << chan % 16);
2413 /* Prepare space for response in memory */
2414 memset(resp, 0xff, sizeof(resp));
2415 vp.vp_ctrl_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2416 if (vp.vp_ctrl_handle == 0) {
2417 isp_prt(isp, ISP_LOGERR,
2418 "%s: VP_CTRL of Chan %d out of handles", __func__, chan);
2422 /* Send request and wait for response. */
2423 reqp = isp_getrqentry(isp);
2425 isp_prt(isp, ISP_LOGERR,
2426 "%s: VP_CTRL of Chan %d out of rqent", __func__, chan);
2427 isp_destroy_handle(isp, vp.vp_ctrl_handle);
2430 isp_put_vp_ctrl_info(isp, &vp, (vp_ctrl_info_t *)reqp);
2431 if (isp->isp_dblev & ISP_LOGDEBUG1)
2432 isp_print_bytes(isp, "IOCB VP_CTRL", QENTRY_LEN, reqp);
2433 ISP_SYNC_REQUEST(isp);
2434 if (msleep(resp, &isp->isp_lock, 0, "VP_CTRL", 5*hz) == EWOULDBLOCK) {
2435 isp_prt(isp, ISP_LOGERR,
2436 "%s: VP_CTRL of Chan %d timed out", __func__, chan);
2437 isp_destroy_handle(isp, vp.vp_ctrl_handle);
2440 if (isp->isp_dblev & ISP_LOGDEBUG1)
2441 isp_print_bytes(isp, "IOCB VP_CTRL response", QENTRY_LEN, resp);
2442 isp_get_vp_ctrl_info(isp, (vp_ctrl_info_t *)resp, &vp);
2444 if (vp.vp_ctrl_hdr.rqs_flags != 0 || vp.vp_ctrl_status != 0) {
2445 isp_prt(isp, ISP_LOGERR,
2446 "%s: VP_CTRL of Chan %d failed with flags %x status %d %d",
2447 __func__, chan, vp.vp_ctrl_hdr.rqs_flags,
2448 vp.vp_ctrl_status, vp.vp_ctrl_index_fail);
2455 isp_fc_change_role(ispsoftc_t *isp, int chan, int new_role)
2457 fcparam *fcp = FCPARAM(isp, chan);
2458 int i, was, res = 0;
2460 if (chan >= isp->isp_nchan) {
2461 isp_prt(isp, ISP_LOGWARN, "%s: bad channel %d", __func__, chan);
2464 if (fcp->role == new_role)
2466 for (was = 0, i = 0; i < isp->isp_nchan; i++) {
2467 if (FCPARAM(isp, i)->role != ISP_ROLE_NONE)
2470 if (was == 0 || (was == 1 && fcp->role != ISP_ROLE_NONE)) {
2471 fcp->role = new_role;
2472 return (isp_reinit(isp, 0));
2474 if (fcp->role != ISP_ROLE_NONE) {
2475 res = isp_fc_disable_vp(isp, chan);
2476 isp_clear_portdb(isp, chan);
2478 fcp->role = new_role;
2479 if (fcp->role != ISP_ROLE_NONE)
2480 res = isp_fc_enable_vp(isp, chan);
2485 isp_clear_portdb(ispsoftc_t *isp, int chan)
2487 fcparam *fcp = FCPARAM(isp, chan);
2491 for (i = 0; i < MAX_FC_TARG; i++) {
2492 lp = &fcp->portdb[i];
2493 switch (lp->state) {
2494 case FC_PORTDB_STATE_DEAD:
2495 case FC_PORTDB_STATE_CHANGED:
2496 case FC_PORTDB_STATE_VALID:
2497 lp->state = FC_PORTDB_STATE_NIL;
2498 isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
2500 case FC_PORTDB_STATE_NIL:
2501 case FC_PORTDB_STATE_NEW:
2502 lp->state = FC_PORTDB_STATE_NIL;
2504 case FC_PORTDB_STATE_ZOMBIE:
2507 panic("Don't know how to clear state %d\n", lp->state);
2513 isp_mark_portdb(ispsoftc_t *isp, int chan)
2515 fcparam *fcp = FCPARAM(isp, chan);
2519 for (i = 0; i < MAX_FC_TARG; i++) {
2520 lp = &fcp->portdb[i];
2521 if (lp->state == FC_PORTDB_STATE_NIL)
2523 if (lp->portid >= DOMAIN_CONTROLLER_BASE &&
2524 lp->portid <= DOMAIN_CONTROLLER_END)
2526 fcp->portdb[i].probational = 1;
2531 * Perform an IOCB PLOGI or LOGO via EXECUTE IOCB A64 for 24XX cards
2532 * or via FABRIC LOGIN/FABRIC LOGOUT for other cards.
2535 isp_plogx(ispsoftc_t *isp, int chan, uint16_t handle, uint32_t portid, int flags)
2539 uint8_t resp[QENTRY_LEN];
2540 uint32_t sst, parm1;
2545 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d PLOGX %s PortID 0x%06x nphdl 0x%x",
2546 chan, (flags & PLOGX_FLG_CMD_MASK) == PLOGX_FLG_CMD_PLOGI ?
2547 "Login":"Logout", portid, handle);
2548 if (!IS_24XX(isp)) {
2549 int action = flags & PLOGX_FLG_CMD_MASK;
2550 if (action == PLOGX_FLG_CMD_PLOGI) {
2551 return (isp_port_login(isp, handle, portid));
2552 } else if (action == PLOGX_FLG_CMD_LOGO) {
2553 return (isp_port_logout(isp, handle, portid));
2555 return (MBOX_INVALID_COMMAND);
2559 ISP_MEMZERO(&pl, sizeof(pl));
2560 pl.plogx_header.rqs_entry_count = 1;
2561 pl.plogx_header.rqs_entry_type = RQSTYPE_LOGIN;
2562 pl.plogx_nphdl = handle;
2563 pl.plogx_vphdl = chan;
2564 pl.plogx_portlo = portid;
2565 pl.plogx_rspsz_porthi = (portid >> 16) & 0xff;
2566 pl.plogx_flags = flags;
2568 /* Prepare space for response in memory */
2569 memset(resp, 0xff, sizeof(resp));
2570 pl.plogx_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2571 if (pl.plogx_handle == 0) {
2572 isp_prt(isp, ISP_LOGERR,
2573 "%s: PLOGX of Chan %d out of handles", __func__, chan);
2577 /* Send request and wait for response. */
2578 reqp = isp_getrqentry(isp);
2580 isp_prt(isp, ISP_LOGERR,
2581 "%s: PLOGX of Chan %d out of rqent", __func__, chan);
2582 isp_destroy_handle(isp, pl.plogx_handle);
2585 isp_put_plogx(isp, &pl, (isp_plogx_t *)reqp);
2586 if (isp->isp_dblev & ISP_LOGDEBUG1)
2587 isp_print_bytes(isp, "IOCB LOGX", QENTRY_LEN, reqp);
2588 FCPARAM(isp, chan)->isp_login_hdl = handle;
2589 ISP_SYNC_REQUEST(isp);
2590 if (msleep(resp, &isp->isp_lock, 0, "PLOGX", 3 * ICB_LOGIN_TOV * hz)
2592 isp_prt(isp, ISP_LOGERR,
2593 "%s: PLOGX of Chan %d timed out", __func__, chan);
2594 isp_destroy_handle(isp, pl.plogx_handle);
2597 FCPARAM(isp, chan)->isp_login_hdl = NIL_HANDLE;
2598 if (isp->isp_dblev & ISP_LOGDEBUG1)
2599 isp_print_bytes(isp, "IOCB LOGX response", QENTRY_LEN, resp);
2600 isp_get_plogx(isp, (isp_plogx_t *)resp, &pl);
2602 if (pl.plogx_status == PLOGX_STATUS_OK) {
2604 } else if (pl.plogx_status != PLOGX_STATUS_IOCBERR) {
2605 isp_prt(isp, ISP_LOGWARN,
2606 "status 0x%x on port login IOCB channel %d",
2607 pl.plogx_status, chan);
2611 sst = pl.plogx_ioparm[0].lo16 | (pl.plogx_ioparm[0].hi16 << 16);
2612 parm1 = pl.plogx_ioparm[1].lo16 | (pl.plogx_ioparm[1].hi16 << 16);
2619 case PLOGX_IOCBERR_NOLINK:
2622 case PLOGX_IOCBERR_NOIOCB:
2623 msg = "no IOCB buffer";
2625 case PLOGX_IOCBERR_NOXGHG:
2626 msg = "no Exchange Control Block";
2628 case PLOGX_IOCBERR_FAILED:
2629 ISP_SNPRINTF(buf, sizeof (buf), "reason 0x%x (last LOGIN state 0x%x)", parm1 & 0xff, (parm1 >> 8) & 0xff);
2632 case PLOGX_IOCBERR_NOFABRIC:
2635 case PLOGX_IOCBERR_NOTREADY:
2636 msg = "firmware not ready";
2638 case PLOGX_IOCBERR_NOLOGIN:
2639 ISP_SNPRINTF(buf, sizeof (buf), "not logged in (last state 0x%x)", parm1);
2641 rval = MBOX_NOT_LOGGED_IN;
2643 case PLOGX_IOCBERR_REJECT:
2644 ISP_SNPRINTF(buf, sizeof (buf), "LS_RJT = 0x%x", parm1);
2647 case PLOGX_IOCBERR_NOPCB:
2648 msg = "no PCB allocated";
2650 case PLOGX_IOCBERR_EINVAL:
2651 ISP_SNPRINTF(buf, sizeof (buf), "invalid parameter at offset 0x%x", parm1);
2654 case PLOGX_IOCBERR_PORTUSED:
2655 lev = ISP_LOG_SANCFG|ISP_LOG_WARN1;
2656 ISP_SNPRINTF(buf, sizeof (buf), "already logged in with N-Port handle 0x%x", parm1);
2658 rval = MBOX_PORT_ID_USED | (parm1 << 16);
2660 case PLOGX_IOCBERR_HNDLUSED:
2661 lev = ISP_LOG_SANCFG|ISP_LOG_WARN1;
2662 ISP_SNPRINTF(buf, sizeof (buf), "handle already used for PortID 0x%06x", parm1);
2664 rval = MBOX_LOOP_ID_USED;
2666 case PLOGX_IOCBERR_NOHANDLE:
2667 msg = "no handle allocated";
2669 case PLOGX_IOCBERR_NOFLOGI:
2670 msg = "no FLOGI_ACC";
2673 ISP_SNPRINTF(buf, sizeof (buf), "status %x from %x", pl.plogx_status, flags);
2678 isp_prt(isp, lev, "Chan %d PLOGX PortID 0x%06x to N-Port handle 0x%x: %s",
2679 chan, portid, handle, msg);
2685 isp_port_login(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2689 MBSINIT(&mbs, MBOX_FABRIC_LOGIN, MBLOGNONE, 500000);
2690 if (ISP_CAP_2KLOGIN(isp)) {
2691 mbs.param[1] = handle;
2692 mbs.ibits = (1 << 10);
2694 mbs.param[1] = handle << 8;
2696 mbs.param[2] = portid >> 16;
2697 mbs.param[3] = portid;
2698 mbs.logval = MBLOGNONE;
2699 mbs.timeout = 500000;
2700 isp_mboxcmd(isp, &mbs);
2702 switch (mbs.param[0]) {
2703 case MBOX_PORT_ID_USED:
2704 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: portid 0x%06x already logged in as 0x%x", portid, mbs.param[1]);
2705 return (MBOX_PORT_ID_USED | (mbs.param[1] << 16));
2707 case MBOX_LOOP_ID_USED:
2708 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: handle 0x%x in use for port id 0x%02xXXXX", handle, mbs.param[1] & 0xff);
2709 return (MBOX_LOOP_ID_USED);
2711 case MBOX_COMMAND_COMPLETE:
2714 case MBOX_COMMAND_ERROR:
2715 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: error 0x%x in PLOGI to port 0x%06x", mbs.param[1], portid);
2716 return (MBOX_COMMAND_ERROR);
2718 case MBOX_ALL_IDS_USED:
2719 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: all IDs used for fabric login");
2720 return (MBOX_ALL_IDS_USED);
2723 isp_prt(isp, ISP_LOG_SANCFG, "isp_port_login: error 0x%x on port login of 0x%06x@0x%0x", mbs.param[0], portid, handle);
2724 return (mbs.param[0]);
2729 * Pre-24XX fabric port logout
2731 * Note that portid is not used
2734 isp_port_logout(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2738 MBSINIT(&mbs, MBOX_FABRIC_LOGOUT, MBLOGNONE, 500000);
2739 if (ISP_CAP_2KLOGIN(isp)) {
2740 mbs.param[1] = handle;
2741 mbs.ibits = (1 << 10);
2743 mbs.param[1] = handle << 8;
2745 isp_mboxcmd(isp, &mbs);
2746 return (mbs.param[0] == MBOX_COMMAND_COMPLETE? 0 : mbs.param[0]);
2750 isp_getpdb(ispsoftc_t *isp, int chan, uint16_t id, isp_pdb_t *pdb)
2754 isp_pdb_21xx_t fred;
2755 isp_pdb_24xx_t bill;
2758 MBSINIT(&mbs, MBOX_GET_PORT_DB,
2759 MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_PARAM_ERROR), 250000);
2761 mbs.ibits = (1 << 9)|(1 << 10);
2763 mbs.param[9] = chan;
2764 } else if (ISP_CAP_2KLOGIN(isp)) {
2767 mbs.param[1] = id << 8;
2769 mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
2770 mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
2771 mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
2772 mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
2773 MEMORYBARRIER(isp, SYNC_IFORDEV, 0, sizeof(un), chan);
2775 isp_mboxcmd(isp, &mbs);
2776 if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
2777 return (mbs.param[0] | (mbs.param[1] << 16));
2779 MEMORYBARRIER(isp, SYNC_IFORCPU, 0, sizeof(un), chan);
2781 isp_get_pdb_24xx(isp, isp->isp_iocb, &un.bill);
2782 pdb->handle = un.bill.pdb_handle;
2783 pdb->prli_word3 = un.bill.pdb_prli_svc3;
2784 pdb->portid = BITS2WORD_24XX(un.bill.pdb_portid_bits);
2785 ISP_MEMCPY(pdb->portname, un.bill.pdb_portname, 8);
2786 ISP_MEMCPY(pdb->nodename, un.bill.pdb_nodename, 8);
2787 isp_prt(isp, ISP_LOGDEBUG0,
2788 "Chan %d handle 0x%x Port 0x%06x flags 0x%x curstate %x laststate %x",
2789 chan, id, pdb->portid, un.bill.pdb_flags,
2790 un.bill.pdb_curstate, un.bill.pdb_laststate);
2792 if (un.bill.pdb_curstate < PDB2400_STATE_PLOGI_DONE || un.bill.pdb_curstate > PDB2400_STATE_LOGGED_IN) {
2793 mbs.param[0] = MBOX_NOT_LOGGED_IN;
2794 return (mbs.param[0]);
2797 isp_get_pdb_21xx(isp, isp->isp_iocb, &un.fred);
2798 pdb->handle = un.fred.pdb_loopid;
2799 pdb->prli_word3 = un.fred.pdb_prli_svc3;
2800 pdb->portid = BITS2WORD(un.fred.pdb_portid_bits);
2801 ISP_MEMCPY(pdb->portname, un.fred.pdb_portname, 8);
2802 ISP_MEMCPY(pdb->nodename, un.fred.pdb_nodename, 8);
2803 isp_prt(isp, ISP_LOGDEBUG1,
2804 "Chan %d handle 0x%x Port 0x%06x", chan, id, pdb->portid);
2810 isp_gethandles(ispsoftc_t *isp, int chan, uint16_t *handles, int *num, int loop)
2812 fcparam *fcp = FCPARAM(isp, chan);
2814 isp_pnhle_21xx_t el1, *elp1;
2815 isp_pnhle_23xx_t el3, *elp3;
2816 isp_pnhle_24xx_t el4, *elp4;
2821 MBSINIT(&mbs, MBOX_GET_ID_LIST, MBLOGALL, 250000);
2823 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2824 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2825 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2826 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2827 mbs.param[8] = ISP_FC_SCRLEN;
2828 mbs.param[9] = chan;
2830 mbs.ibits = (1 << 1)|(1 << 2)|(1 << 3)|(1 << 6);
2831 mbs.param[1] = DMA_WD1(fcp->isp_scdma);
2832 mbs.param[2] = DMA_WD0(fcp->isp_scdma);
2833 mbs.param[3] = DMA_WD3(fcp->isp_scdma);
2834 mbs.param[6] = DMA_WD2(fcp->isp_scdma);
2836 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2837 isp_prt(isp, ISP_LOGERR, sacq);
2840 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, ISP_FC_SCRLEN, chan);
2841 isp_mboxcmd(isp, &mbs);
2842 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2843 FC_SCRATCH_RELEASE(isp, chan);
2844 return (mbs.param[0] | (mbs.param[1] << 16));
2846 MEMORYBARRIER(isp, SYNC_SFORCPU, 0, ISP_FC_SCRLEN, chan);
2847 elp1 = fcp->isp_scratch;
2848 elp3 = fcp->isp_scratch;
2849 elp4 = fcp->isp_scratch;
2850 for (i = 0, j = 0; i < mbs.param[1] && j < *num; i++) {
2852 isp_get_pnhle_24xx(isp, &elp4[i], &el4);
2853 p = el4.pnhle_port_id_lo |
2854 (el4.pnhle_port_id_hi << 16);
2855 h = el4.pnhle_handle;
2856 } else if (IS_23XX(isp)) {
2857 isp_get_pnhle_23xx(isp, &elp3[i], &el3);
2858 p = el3.pnhle_port_id_lo |
2859 (el3.pnhle_port_id_hi << 16);
2860 h = el3.pnhle_handle;
2862 isp_get_pnhle_21xx(isp, &elp1[i], &el1);
2863 p = el1.pnhle_port_id_lo |
2864 ((el1.pnhle_port_id_hi_handle & 0xff) << 16);
2865 h = el1.pnhle_port_id_hi_handle >> 8;
2867 if (loop && (p >> 8) != (fcp->isp_portid >> 8))
2872 FC_SCRATCH_RELEASE(isp, chan);
2877 isp_dump_chip_portdb(ispsoftc_t *isp, int chan)
2880 uint16_t lim, nphdl;
2882 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d chip port dump", chan);
2883 if (ISP_CAP_2KLOGIN(isp)) {
2888 for (nphdl = 0; nphdl != lim; nphdl++) {
2889 if (isp_getpdb(isp, chan, nphdl, &pdb)) {
2892 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d Handle 0x%04x "
2893 "PortID 0x%06x WWPN 0x%02x%02x%02x%02x%02x%02x%02x%02x",
2894 chan, nphdl, pdb.portid, pdb.portname[0], pdb.portname[1],
2895 pdb.portname[2], pdb.portname[3], pdb.portname[4],
2896 pdb.portname[5], pdb.portname[6], pdb.portname[7]);
2901 isp_get_wwn(ispsoftc_t *isp, int chan, int nphdl, int nodename)
2903 uint64_t wwn = INI_NONE;
2906 MBSINIT(&mbs, MBOX_GET_PORT_NAME,
2907 MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_PARAM_ERROR), 500000);
2908 if (ISP_CAP_2KLOGIN(isp)) {
2909 mbs.param[1] = nphdl;
2913 mbs.param[9] = chan;
2916 mbs.param[1] = nphdl << 8;
2921 isp_mboxcmd(isp, &mbs);
2922 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2927 (((uint64_t)(mbs.param[2] >> 8)) << 56) |
2928 (((uint64_t)(mbs.param[2] & 0xff)) << 48) |
2929 (((uint64_t)(mbs.param[3] >> 8)) << 40) |
2930 (((uint64_t)(mbs.param[3] & 0xff)) << 32) |
2931 (((uint64_t)(mbs.param[6] >> 8)) << 24) |
2932 (((uint64_t)(mbs.param[6] & 0xff)) << 16) |
2933 (((uint64_t)(mbs.param[7] >> 8)) << 8) |
2934 (((uint64_t)(mbs.param[7] & 0xff)));
2937 (((uint64_t)(mbs.param[2] & 0xff)) << 56) |
2938 (((uint64_t)(mbs.param[2] >> 8)) << 48) |
2939 (((uint64_t)(mbs.param[3] & 0xff)) << 40) |
2940 (((uint64_t)(mbs.param[3] >> 8)) << 32) |
2941 (((uint64_t)(mbs.param[6] & 0xff)) << 24) |
2942 (((uint64_t)(mbs.param[6] >> 8)) << 16) |
2943 (((uint64_t)(mbs.param[7] & 0xff)) << 8) |
2944 (((uint64_t)(mbs.param[7] >> 8)));
2950 * Make sure we have good FC link.
2954 isp_fclink_test(ispsoftc_t *isp, int chan, int usdelay)
2961 NANOTIME_T hra, hrb;
2963 fcp = FCPARAM(isp, chan);
2965 if (fcp->isp_loopstate < LOOP_HAVE_LINK)
2967 if (fcp->isp_loopstate >= LOOP_LTEST_DONE)
2970 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test", chan);
2973 * Wait up to N microseconds for F/W to go to a ready state.
2977 isp_change_fw_state(isp, chan, isp_fw_state(isp, chan));
2978 if (fcp->isp_fwstate == FW_READY) {
2981 if (fcp->isp_loopstate < LOOP_HAVE_LINK)
2984 if ((NANOTIME_SUB(&hrb, &hra) / 1000 + 1000 >= usdelay))
2986 ISP_SLEEP(isp, 1000);
2988 if (fcp->isp_fwstate != FW_READY) {
2989 isp_prt(isp, ISP_LOG_SANCFG,
2990 "Chan %d Firmware is not ready (%s)",
2991 chan, isp_fc_fw_statename(fcp->isp_fwstate));
2996 * Get our Loop ID and Port ID.
2998 MBSINIT(&mbs, MBOX_GET_LOOP_ID, MBLOGALL, 0);
2999 mbs.param[9] = chan;
3000 isp_mboxcmd(isp, &mbs);
3001 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3007 * Don't bother with fabric if we are using really old
3008 * 2100 firmware. It's just not worth it.
3010 if (ISP_FW_NEWER_THAN(isp, 1, 15, 37))
3011 fcp->isp_topo = TOPO_FL_PORT;
3013 fcp->isp_topo = TOPO_NL_PORT;
3015 int topo = (int) mbs.param[6];
3016 if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB) {
3017 topo = TOPO_PTP_STUB;
3019 fcp->isp_topo = topo;
3021 fcp->isp_portid = mbs.param[2] | (mbs.param[3] << 16);
3023 if (!TOPO_IS_FABRIC(fcp->isp_topo)) {
3024 fcp->isp_loopid = mbs.param[1] & 0xff;
3025 } else if (fcp->isp_topo != TOPO_F_PORT) {
3026 uint8_t alpa = fcp->isp_portid;
3028 for (i = 0; alpa_map[i]; i++) {
3029 if (alpa_map[i] == alpa)
3033 fcp->isp_loopid = i;
3037 fcp->isp_loopstate = LOOP_HAVE_ADDR;
3039 fcp->isp_loopstate = LOOP_TESTING_LINK;
3041 if (fcp->isp_topo == TOPO_F_PORT || fcp->isp_topo == TOPO_FL_PORT) {
3042 nphdl = IS_24XX(isp) ? NPH_FL_ID : FL_ID;
3043 r = isp_getpdb(isp, chan, nphdl, &pdb);
3044 if (r != 0 || pdb.portid == 0) {
3046 fcp->isp_topo = TOPO_NL_PORT;
3048 isp_prt(isp, ISP_LOGWARN,
3049 "fabric topology, but cannot get info about fabric controller (0x%x)", r);
3050 fcp->isp_topo = TOPO_PTP_STUB;
3056 fcp->isp_fabric_params = mbs.param[7];
3057 fcp->isp_sns_hdl = NPH_SNS_ID;
3058 r = isp_register_fc4_type(isp, chan);
3059 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3063 r = isp_register_fc4_features_24xx(isp, chan);
3064 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3068 r = isp_register_port_name_24xx(isp, chan);
3069 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3073 isp_register_node_name_24xx(isp, chan);
3074 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3077 fcp->isp_sns_hdl = SNS_ID;
3078 r = isp_register_fc4_type(isp, chan);
3081 if (fcp->role == ISP_ROLE_TARGET)
3082 isp_send_change_request(isp, chan);
3087 /* Get link speed. */
3088 fcp->isp_gbspeed = 1;
3089 if (IS_23XX(isp) || IS_24XX(isp)) {
3090 MBSINIT(&mbs, MBOX_GET_SET_DATA_RATE, MBLOGALL, 3000000);
3091 mbs.param[1] = MBGSD_GET_RATE;
3092 /* mbs.param[2] undefined if we're just getting rate */
3093 isp_mboxcmd(isp, &mbs);
3094 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3095 if (mbs.param[1] == MBGSD_10GB)
3096 fcp->isp_gbspeed = 10;
3097 else if (mbs.param[1] == MBGSD_16GB)
3098 fcp->isp_gbspeed = 16;
3099 else if (mbs.param[1] == MBGSD_8GB)
3100 fcp->isp_gbspeed = 8;
3101 else if (mbs.param[1] == MBGSD_4GB)
3102 fcp->isp_gbspeed = 4;
3103 else if (mbs.param[1] == MBGSD_2GB)
3104 fcp->isp_gbspeed = 2;
3105 else if (mbs.param[1] == MBGSD_1GB)
3106 fcp->isp_gbspeed = 1;
3110 if (fcp->isp_loopstate < LOOP_TESTING_LINK) {
3112 isp_prt(isp, ISP_LOG_SANCFG,
3113 "Chan %d FC link test aborted", chan);
3116 fcp->isp_loopstate = LOOP_LTEST_DONE;
3117 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
3118 "Chan %d WWPN %016jx WWNN %016jx",
3119 chan, (uintmax_t)fcp->isp_wwpn, (uintmax_t)fcp->isp_wwnn);
3120 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
3121 "Chan %d %dGb %s PortID 0x%06x LoopID 0x%02x",
3122 chan, fcp->isp_gbspeed, isp_fc_toponame(fcp), fcp->isp_portid,
3124 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test done", chan);
3129 * Complete the synchronization of our Port Database.
3131 * At this point, we've scanned the local loop (if any) and the fabric
3132 * and performed fabric logins on all new devices.
3134 * Our task here is to go through our port database removing any entities
3135 * that are still marked probational (issuing PLOGO for ones which we had
3136 * PLOGI'd into) or are dead, and notifying upper layers about new/changed
3140 isp_pdb_sync(ispsoftc_t *isp, int chan)
3142 fcparam *fcp = FCPARAM(isp, chan);
3146 if (fcp->isp_loopstate < LOOP_FSCAN_DONE)
3148 if (fcp->isp_loopstate >= LOOP_READY)
3151 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync", chan);
3153 fcp->isp_loopstate = LOOP_SYNCING_PDB;
3155 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3156 lp = &fcp->portdb[dbidx];
3158 if (lp->state == FC_PORTDB_STATE_NIL)
3160 if (lp->probational && lp->state != FC_PORTDB_STATE_ZOMBIE)
3161 lp->state = FC_PORTDB_STATE_DEAD;
3162 switch (lp->state) {
3163 case FC_PORTDB_STATE_DEAD:
3164 lp->state = FC_PORTDB_STATE_NIL;
3165 isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
3166 if ((lp->portid & 0xffff00) != 0) {
3167 (void) isp_plogx(isp, chan, lp->handle,
3169 PLOGX_FLG_CMD_LOGO |
3170 PLOGX_FLG_IMPLICIT |
3171 PLOGX_FLG_FREE_NPHDL);
3174 * Note that we might come out of this with our state
3175 * set to FC_PORTDB_STATE_ZOMBIE.
3178 case FC_PORTDB_STATE_NEW:
3179 lp->state = FC_PORTDB_STATE_VALID;
3180 isp_async(isp, ISPASYNC_DEV_ARRIVED, chan, lp);
3182 case FC_PORTDB_STATE_CHANGED:
3183 lp->state = FC_PORTDB_STATE_VALID;
3184 isp_async(isp, ISPASYNC_DEV_CHANGED, chan, lp);
3185 lp->portid = lp->new_portid;
3186 lp->prli_word3 = lp->new_prli_word3;
3188 case FC_PORTDB_STATE_VALID:
3189 isp_async(isp, ISPASYNC_DEV_STAYED, chan, lp);
3191 case FC_PORTDB_STATE_ZOMBIE:
3194 isp_prt(isp, ISP_LOGWARN,
3195 "isp_pdb_sync: state %d for idx %d",
3197 isp_dump_portdb(isp, chan);
3201 if (fcp->isp_loopstate < LOOP_SYNCING_PDB) {
3202 isp_prt(isp, ISP_LOG_SANCFG,
3203 "Chan %d FC PDB sync aborted", chan);
3207 fcp->isp_loopstate = LOOP_READY;
3208 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync done", chan);
3213 isp_pdb_add_update(ispsoftc_t *isp, int chan, isp_pdb_t *pdb)
3216 uint64_t wwnn, wwpn;
3218 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb->nodename);
3219 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb->portname);
3221 /* Search port database for the same WWPN. */
3222 if (isp_find_pdb_by_wwpn(isp, chan, wwpn, &lp)) {
3223 if (!lp->probational) {
3224 isp_prt(isp, ISP_LOGERR,
3225 "Chan %d Port 0x%06x@0x%04x [%d] is not probational (0x%x)",
3226 chan, lp->portid, lp->handle,
3227 FC_PORTDB_TGT(isp, chan, lp), lp->state);
3228 isp_dump_portdb(isp, chan);
3231 lp->probational = 0;
3232 lp->node_wwn = wwnn;
3234 /* Old device, nothing new. */
3235 if (lp->portid == pdb->portid &&
3236 lp->handle == pdb->handle &&
3237 lp->prli_word3 == pdb->prli_word3) {
3238 if (lp->state != FC_PORTDB_STATE_NEW)
3239 lp->state = FC_PORTDB_STATE_VALID;
3240 isp_prt(isp, ISP_LOG_SANCFG,
3241 "Chan %d Port 0x%06x@0x%04x is valid",
3242 chan, pdb->portid, pdb->handle);
3246 /* Something has changed. */
3247 lp->state = FC_PORTDB_STATE_CHANGED;
3248 lp->handle = pdb->handle;
3249 lp->new_portid = pdb->portid;
3250 lp->new_prli_word3 = pdb->prli_word3;
3251 isp_prt(isp, ISP_LOG_SANCFG,
3252 "Chan %d Port 0x%06x@0x%04x is changed",
3253 chan, pdb->portid, pdb->handle);
3257 /* It seems like a new port. Find an empty slot for it. */
3258 if (!isp_find_pdb_empty(isp, chan, &lp)) {
3259 isp_prt(isp, ISP_LOGERR, "Chan %d out of portdb entries", chan);
3263 ISP_MEMZERO(lp, sizeof (fcportdb_t));
3264 lp->probational = 0;
3265 lp->state = FC_PORTDB_STATE_NEW;
3266 lp->portid = lp->new_portid = pdb->portid;
3267 lp->prli_word3 = lp->new_prli_word3 = pdb->prli_word3;
3268 lp->handle = pdb->handle;
3269 lp->port_wwn = wwpn;
3270 lp->node_wwn = wwnn;
3271 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Port 0x%06x@0x%04x is new",
3272 chan, pdb->portid, pdb->handle);
3276 * Fix port IDs for logged-in initiators on pre-2400 chips.
3277 * For those chips we are not receiving login events, adding initiators
3278 * based on ATIO requests, but there is no port ID in that structure.
3281 isp_fix_portids(ispsoftc_t *isp, int chan)
3283 fcparam *fcp = FCPARAM(isp, chan);
3288 for (i = 0; i < MAX_FC_TARG; i++) {
3289 fcportdb_t *lp = &fcp->portdb[i];
3291 if (lp->state == FC_PORTDB_STATE_NIL ||
3292 lp->state == FC_PORTDB_STATE_ZOMBIE)
3294 if (VALID_PORT(lp->portid))
3297 r = isp_getpdb(isp, chan, lp->handle, &pdb);
3298 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3301 isp_prt(isp, ISP_LOGDEBUG1,
3302 "Chan %d FC Scan Loop handle %d returned %x",
3303 chan, lp->handle, r);
3307 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3308 if (lp->port_wwn != wwpn)
3310 lp->portid = lp->new_portid = pdb.portid;
3311 isp_prt(isp, ISP_LOG_SANCFG,
3312 "Chan %d Port 0x%06x@0x%04x is fixed",
3313 chan, pdb.portid, pdb.handle);
3318 * Scan local loop for devices.
3321 isp_scan_loop(ispsoftc_t *isp, int chan)
3323 fcparam *fcp = FCPARAM(isp, chan);
3329 if (fcp->isp_loopstate < LOOP_LTEST_DONE)
3331 if (fcp->isp_loopstate >= LOOP_LSCAN_DONE)
3334 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan", chan);
3335 fcp->isp_loopstate = LOOP_SCANNING_LOOP;
3336 if (TOPO_IS_FABRIC(fcp->isp_topo)) {
3337 if (!IS_24XX(isp)) {
3338 isp_fix_portids(isp, chan);
3339 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3342 isp_prt(isp, ISP_LOG_SANCFG,
3343 "Chan %d FC loop scan done (no loop)", chan);
3344 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3348 handles = (uint16_t *)fcp->isp_scanscratch;
3349 lim = ISP_FC_SCRLEN / 2;
3350 r = isp_gethandles(isp, chan, handles, &lim, 1);
3352 isp_prt(isp, ISP_LOG_SANCFG,
3353 "Chan %d Getting list of handles failed with %x", chan, r);
3354 isp_prt(isp, ISP_LOG_SANCFG,
3355 "Chan %d FC loop scan done (bad)", chan);
3359 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Got %d handles",
3363 * Run through the list and get the port database info for each one.
3365 isp_mark_portdb(isp, chan);
3366 for (idx = 0; idx < lim; idx++) {
3367 handle = handles[idx];
3370 * Don't scan "special" ids.
3372 if (ISP_CAP_2KLOGIN(isp)) {
3373 if (handle >= NPH_RESERVED)
3376 if (handle >= FL_ID && handle <= SNS_ID)
3381 * In older cards with older f/w GET_PORT_DATABASE has been
3382 * known to hang. This trick gets around that problem.
3384 if (IS_2100(isp) || IS_2200(isp)) {
3385 uint64_t node_wwn = isp_get_wwn(isp, chan, handle, 1);
3386 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
3388 isp_prt(isp, ISP_LOG_SANCFG,
3389 "Chan %d FC loop scan aborted", chan);
3392 if (node_wwn == INI_NONE) {
3398 * Get the port database entity for this index.
3400 r = isp_getpdb(isp, chan, handle, &pdb);
3401 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3404 isp_prt(isp, ISP_LOGDEBUG1,
3405 "Chan %d FC Scan Loop handle %d returned %x",
3410 isp_pdb_add_update(isp, chan, &pdb);
3412 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3414 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3415 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan done", chan);
3420 isp_ct_sns(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
3422 fcparam *fcp = FCPARAM(isp, chan);
3425 if (isp->isp_dblev & ISP_LOGDEBUG1)
3426 isp_print_bytes(isp, "CT SNS request", cmd_bcnt, fcp->isp_scratch);
3427 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, cmd_bcnt, chan);
3429 MBSINIT(&mbs, MBOX_SEND_SNS, MBLOGALL, 10000000);
3430 mbs.param[1] = cmd_bcnt >> 1;
3431 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
3432 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
3433 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
3434 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
3435 isp_mboxcmd(isp, &mbs);
3436 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3437 if (mbs.param[0] == MBOX_INVALID_COMMAND) {
3444 MEMORYBARRIER(isp, SYNC_SFORCPU, 0, rsp_bcnt, chan);
3445 if (isp->isp_dblev & ISP_LOGDEBUG1)
3446 isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
3451 isp_ct_passthru(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
3453 fcparam *fcp = FCPARAM(isp, chan);
3456 uint8_t resp[QENTRY_LEN];
3458 if (isp->isp_dblev & ISP_LOGDEBUG1)
3459 isp_print_bytes(isp, "CT request", cmd_bcnt, fcp->isp_scratch);
3462 * Build a Passthrough IOCB in memory.
3464 ISP_MEMZERO(&pt, sizeof(pt));
3465 pt.ctp_header.rqs_entry_count = 1;
3466 pt.ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
3467 pt.ctp_nphdl = fcp->isp_sns_hdl;
3469 pt.ctp_vpidx = ISP_GET_VPIDX(isp, chan);
3472 pt.ctp_rsp_bcnt = rsp_bcnt;
3473 pt.ctp_cmd_bcnt = cmd_bcnt;
3474 pt.ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma);
3475 pt.ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma);
3476 pt.ctp_dataseg[0].ds_count = cmd_bcnt;
3477 pt.ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma);
3478 pt.ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma);
3479 pt.ctp_dataseg[1].ds_count = rsp_bcnt;
3481 /* Prepare space for response in memory */
3482 memset(resp, 0xff, sizeof(resp));
3483 pt.ctp_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
3484 if (pt.ctp_handle == 0) {
3485 isp_prt(isp, ISP_LOGERR,
3486 "%s: CTP of Chan %d out of handles", __func__, chan);
3490 /* Send request and wait for response. */
3491 reqp = isp_getrqentry(isp);
3493 isp_prt(isp, ISP_LOGERR,
3494 "%s: CTP of Chan %d out of rqent", __func__, chan);
3495 isp_destroy_handle(isp, pt.ctp_handle);
3498 isp_put_ct_pt(isp, &pt, (isp_ct_pt_t *)reqp);
3499 if (isp->isp_dblev & ISP_LOGDEBUG1)
3500 isp_print_bytes(isp, "CT IOCB request", QENTRY_LEN, reqp);
3501 ISP_SYNC_REQUEST(isp);
3502 if (msleep(resp, &isp->isp_lock, 0, "CTP", pt.ctp_time*hz) == EWOULDBLOCK) {
3503 isp_prt(isp, ISP_LOGERR,
3504 "%s: CTP of Chan %d timed out", __func__, chan);
3505 isp_destroy_handle(isp, pt.ctp_handle);
3508 if (isp->isp_dblev & ISP_LOGDEBUG1)
3509 isp_print_bytes(isp, "CT IOCB response", QENTRY_LEN, resp);
3511 isp_get_ct_pt(isp, (isp_ct_pt_t *)resp, &pt);
3512 if (pt.ctp_status && pt.ctp_status != RQCS_DATA_UNDERRUN) {
3513 isp_prt(isp, ISP_LOGWARN,
3514 "Chan %d CT pass-through returned 0x%x",
3515 chan, pt.ctp_status);
3519 if (isp->isp_dblev & ISP_LOGDEBUG1)
3520 isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
3526 * Scan the fabric for devices and add them to our port database.
3528 * Use the GID_PT command to get list of all Nx_Port IDs SNS knows.
3529 * Use GFF_ID and GFT_ID to check port type (FCP) and features (target).
3531 * For 2100-23XX cards, we use the SNS mailbox command to pass simple name
3532 * server commands to the switch management server via the QLogic f/w.
3534 * For the 24XX and above card, we use CT Pass-through IOCB.
3536 #define GIDLEN ISP_FC_SCRLEN
3537 #define NGENT ((GIDLEN - 16) >> 2)
3540 isp_gid_pt(ispsoftc_t *isp, int chan)
3542 fcparam *fcp = FCPARAM(isp, chan);
3544 sns_gid_pt_req_t rq;
3545 uint8_t *scp = fcp->isp_scratch;
3547 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GID_PT", chan);
3548 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3549 isp_prt(isp, ISP_LOGERR, sacq);
3554 /* Build the CT command and execute via pass-through. */
3555 ISP_MEMZERO(&ct, sizeof (ct));
3556 ct.ct_revision = CT_REVISION;
3557 ct.ct_fcs_type = CT_FC_TYPE_FC;
3558 ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3559 ct.ct_cmd_resp = SNS_GID_PT;
3560 ct.ct_bcnt_resid = (GIDLEN - 16) >> 2;
3561 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3562 scp[sizeof(ct)] = 0x7f; /* Port Type = Nx_Port */
3563 scp[sizeof(ct)+1] = 0; /* Domain_ID = any */
3564 scp[sizeof(ct)+2] = 0; /* Area_ID = any */
3565 scp[sizeof(ct)+3] = 0; /* Flags = no Area_ID */
3567 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t), GIDLEN)) {
3568 FC_SCRATCH_RELEASE(isp, chan);
3572 /* Build the SNS request and execute via firmware. */
3573 ISP_MEMZERO(&rq, SNS_GID_PT_REQ_SIZE);
3574 rq.snscb_rblen = GIDLEN >> 1;
3575 rq.snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma);
3576 rq.snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma);
3577 rq.snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma);
3578 rq.snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma);
3580 rq.snscb_cmd = SNS_GID_PT;
3581 rq.snscb_mword_div_2 = NGENT;
3582 rq.snscb_port_type = 0x7f; /* Port Type = Nx_Port */
3583 rq.snscb_domain = 0; /* Domain_ID = any */
3584 rq.snscb_area = 0; /* Area_ID = any */
3585 rq.snscb_flags = 0; /* Flags = no Area_ID */
3586 isp_put_gid_pt_request(isp, &rq, (sns_gid_pt_req_t *)scp);
3588 if (isp_ct_sns(isp, chan, sizeof(rq), NGENT)) {
3589 FC_SCRATCH_RELEASE(isp, chan);
3594 isp_get_gid_xx_response(isp, (sns_gid_xx_rsp_t *)scp,
3595 (sns_gid_xx_rsp_t *)fcp->isp_scanscratch, NGENT);
3596 FC_SCRATCH_RELEASE(isp, chan);
3601 isp_gff_id(ispsoftc_t *isp, int chan, uint32_t portid)
3603 fcparam *fcp = FCPARAM(isp, chan);
3606 uint8_t *scp = fcp->isp_scratch;
3607 sns_gff_id_rsp_t rsp;
3610 if (!fcp->isp_use_gff_id) /* User may block GFF_ID use. */
3613 if (!IS_24XX(isp)) /* Old chips can't request GFF_ID. */
3616 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFF_ID", chan);
3617 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3618 isp_prt(isp, ISP_LOGERR, sacq);
3622 /* Build the CT command and execute via pass-through. */
3623 ISP_MEMZERO(&ct, sizeof (ct));
3624 ct.ct_revision = CT_REVISION;
3625 ct.ct_fcs_type = CT_FC_TYPE_FC;
3626 ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3627 ct.ct_cmd_resp = SNS_GFF_ID;
3628 ct.ct_bcnt_resid = (SNS_GFF_ID_RESP_SIZE - sizeof(ct)) / 4;
3629 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3630 rp = (uint32_t *) &scp[sizeof(ct)];
3631 ISP_IOZPUT_32(isp, portid, rp);
3633 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
3634 SNS_GFF_ID_RESP_SIZE)) {
3635 FC_SCRATCH_RELEASE(isp, chan);
3639 isp_get_gff_id_response(isp, (sns_gff_id_rsp_t *)scp, &rsp);
3640 if (rsp.snscb_cthdr.ct_cmd_resp == LS_ACC) {
3641 for (i = 0; i < 32; i++) {
3642 if (rsp.snscb_fc4_features[i] != 0) {
3647 if (((rsp.snscb_fc4_features[FC4_SCSI / 8] >>
3648 ((FC4_SCSI % 8) * 4)) & 0x01) != 0)
3650 /* Workaround for broken Brocade firmware. */
3651 if (((ISP_SWAP32(isp, rsp.snscb_fc4_features[FC4_SCSI / 8]) >>
3652 ((FC4_SCSI % 8) * 4)) & 0x01) != 0)
3655 FC_SCRATCH_RELEASE(isp, chan);
3656 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFF_ID result is %d", chan, res);
3661 isp_gft_id(ispsoftc_t *isp, int chan, uint32_t portid)
3663 fcparam *fcp = FCPARAM(isp, chan);
3665 sns_gxx_id_req_t rq;
3667 uint8_t *scp = fcp->isp_scratch;
3668 sns_gft_id_rsp_t rsp;
3671 if (!fcp->isp_use_gft_id) /* User may block GFT_ID use. */
3674 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFT_ID", chan);
3675 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3676 isp_prt(isp, ISP_LOGERR, sacq);
3681 /* Build the CT command and execute via pass-through. */
3682 ISP_MEMZERO(&ct, sizeof (ct));
3683 ct.ct_revision = CT_REVISION;
3684 ct.ct_fcs_type = CT_FC_TYPE_FC;
3685 ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3686 ct.ct_cmd_resp = SNS_GFT_ID;
3687 ct.ct_bcnt_resid = (SNS_GFT_ID_RESP_SIZE - sizeof(ct)) / 4;
3688 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3689 rp = (uint32_t *) &scp[sizeof(ct)];
3690 ISP_IOZPUT_32(isp, portid, rp);
3692 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
3693 SNS_GFT_ID_RESP_SIZE)) {
3694 FC_SCRATCH_RELEASE(isp, chan);
3698 /* Build the SNS request and execute via firmware. */
3699 ISP_MEMZERO(&rq, SNS_GXX_ID_REQ_SIZE);
3700 rq.snscb_rblen = SNS_GFT_ID_RESP_SIZE >> 1;
3701 rq.snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma);
3702 rq.snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma);
3703 rq.snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma);
3704 rq.snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma);
3706 rq.snscb_cmd = SNS_GFT_ID;
3707 rq.snscb_mword_div_2 = (SNS_GFT_ID_RESP_SIZE - sizeof(ct)) / 4;
3708 rq.snscb_portid = portid;
3709 isp_put_gxx_id_request(isp, &rq, (sns_gxx_id_req_t *)scp);
3711 if (isp_ct_sns(isp, chan, sizeof(rq), SNS_GFT_ID_RESP_SIZE)) {
3712 FC_SCRATCH_RELEASE(isp, chan);
3717 isp_get_gft_id_response(isp, (sns_gft_id_rsp_t *)scp, &rsp);
3718 if (rsp.snscb_cthdr.ct_cmd_resp == LS_ACC) {
3719 for (i = 0; i < 8; i++) {
3720 if (rsp.snscb_fc4_types[i] != 0) {
3725 if (((rsp.snscb_fc4_types[FC4_SCSI / 32] >>
3726 (FC4_SCSI % 32)) & 0x01) != 0)
3729 FC_SCRATCH_RELEASE(isp, chan);
3730 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFT_ID result is %d", chan, res);
3735 isp_scan_fabric(ispsoftc_t *isp, int chan)
3737 fcparam *fcp = FCPARAM(isp, chan);
3742 int portidx, portlim, r;
3743 sns_gid_xx_rsp_t *rs;
3745 if (fcp->isp_loopstate < LOOP_LSCAN_DONE)
3747 if (fcp->isp_loopstate >= LOOP_FSCAN_DONE)
3750 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan", chan);
3751 fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
3752 if (!TOPO_IS_FABRIC(fcp->isp_topo)) {
3753 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3754 isp_prt(isp, ISP_LOG_SANCFG,
3755 "Chan %d FC fabric scan done (no fabric)", chan);
3759 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC) {
3761 FC_SCRATCH_RELEASE(isp, chan);
3762 isp_prt(isp, ISP_LOG_SANCFG,
3763 "Chan %d FC fabric scan aborted", chan);
3768 * Make sure we still are logged into the fabric controller.
3770 nphdl = IS_24XX(isp) ? NPH_FL_ID : FL_ID;
3771 r = isp_getpdb(isp, chan, nphdl, &pdb);
3772 if ((r & 0xffff) == MBOX_NOT_LOGGED_IN) {
3773 isp_dump_chip_portdb(isp, chan);
3776 fcp->isp_loopstate = LOOP_LTEST_DONE;
3778 isp_prt(isp, ISP_LOG_SANCFG,
3779 "Chan %d FC fabric scan done (bad)", chan);
3783 /* Get list of port IDs from SNS. */
3784 r = isp_gid_pt(isp, chan);
3785 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3788 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3791 fcp->isp_loopstate = LOOP_LTEST_DONE; /* try again */
3795 rs = (sns_gid_xx_rsp_t *) fcp->isp_scanscratch;
3796 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3798 if (rs->snscb_cthdr.ct_cmd_resp != LS_ACC) {
3800 /* FC-4 Type and Port Type not registered are not errors. */
3801 if (rs->snscb_cthdr.ct_reason == 9 &&
3802 (rs->snscb_cthdr.ct_explanation == 0x07 ||
3803 rs->snscb_cthdr.ct_explanation == 0x0a)) {
3804 level = ISP_LOG_SANCFG;
3806 level = ISP_LOGWARN;
3808 isp_prt(isp, level, "Chan %d Fabric Nameserver rejected GID_PT"
3809 " (Reason=0x%x Expl=0x%x)", chan,
3810 rs->snscb_cthdr.ct_reason,
3811 rs->snscb_cthdr.ct_explanation);
3812 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3816 /* Check our buffer was big enough to get the full list. */
3817 for (portidx = 0; portidx < NGENT-1; portidx++) {
3818 if (rs->snscb_ports[portidx].control & 0x80)
3821 if ((rs->snscb_ports[portidx].control & 0x80) == 0) {
3822 isp_prt(isp, ISP_LOGWARN,
3823 "fabric too big for scratch area: increase ISP_FC_SCRLEN");
3825 portlim = portidx + 1;
3826 isp_prt(isp, ISP_LOG_SANCFG,
3827 "Chan %d Got %d ports back from name server", chan, portlim);
3829 /* Go through the list and remove duplicate port ids. */
3830 for (portidx = 0; portidx < portlim; portidx++) {
3834 ((rs->snscb_ports[portidx].portid[0]) << 16) |
3835 ((rs->snscb_ports[portidx].portid[1]) << 8) |
3836 ((rs->snscb_ports[portidx].portid[2]));
3838 for (npidx = portidx + 1; npidx < portlim; npidx++) {
3839 uint32_t new_portid =
3840 ((rs->snscb_ports[npidx].portid[0]) << 16) |
3841 ((rs->snscb_ports[npidx].portid[1]) << 8) |
3842 ((rs->snscb_ports[npidx].portid[2]));
3843 if (new_portid == portid) {
3848 if (npidx < portlim) {
3849 rs->snscb_ports[npidx].portid[0] = 0;
3850 rs->snscb_ports[npidx].portid[1] = 0;
3851 rs->snscb_ports[npidx].portid[2] = 0;
3852 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d removing duplicate PortID 0x%06x entry from list", chan, portid);
3857 * We now have a list of Port IDs for all FC4 SCSI devices
3858 * that the Fabric Name server knows about.
3860 * For each entry on this list go through our port database looking
3861 * for probational entries- if we find one, then an old entry is
3862 * maybe still this one. We get some information to find out.
3864 * Otherwise, it's a new fabric device, and we log into it
3865 * (unconditionally). After searching the entire database
3866 * again to make sure that we never ever ever ever have more
3867 * than one entry that has the same PortID or the same
3868 * WWNN/WWPN duple, we enter the device into our database.
3870 isp_mark_portdb(isp, chan);
3871 for (portidx = 0; portidx < portlim; portidx++) {
3872 portid = ((rs->snscb_ports[portidx].portid[0]) << 16) |
3873 ((rs->snscb_ports[portidx].portid[1]) << 8) |
3874 ((rs->snscb_ports[portidx].portid[2]));
3875 isp_prt(isp, ISP_LOG_SANCFG,
3876 "Chan %d Checking fabric port 0x%06x", chan, portid);
3878 isp_prt(isp, ISP_LOG_SANCFG,
3879 "Chan %d Port at idx %d is zero",
3883 if (portid == fcp->isp_portid) {
3884 isp_prt(isp, ISP_LOG_SANCFG,
3885 "Chan %d Port 0x%06x is our", chan, portid);
3889 /* Now search the entire port database for the same portid. */
3890 if (isp_find_pdb_by_portid(isp, chan, portid, &lp)) {
3891 if (!lp->probational) {
3892 isp_prt(isp, ISP_LOGERR,
3893 "Chan %d Port 0x%06x@0x%04x [%d] is not probational (0x%x)",
3894 chan, lp->portid, lp->handle,
3895 FC_PORTDB_TGT(isp, chan, lp), lp->state);
3896 isp_dump_portdb(isp, chan);
3900 if (lp->state == FC_PORTDB_STATE_ZOMBIE)
3904 * See if we're still logged into it.
3906 * If we aren't, mark it as a dead device and
3907 * leave the new portid in the database entry
3908 * for somebody further along to decide what to
3909 * do (policy choice).
3911 * If we are, check to see if it's the same
3912 * device still (it should be). If for some
3913 * reason it isn't, mark it as a changed device
3914 * and leave the new portid and role in the
3915 * database entry for somebody further along to
3916 * decide what to do (policy choice).
3918 r = isp_getpdb(isp, chan, lp->handle, &pdb);
3919 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3922 lp->state = FC_PORTDB_STATE_DEAD;
3923 isp_prt(isp, ISP_LOG_SANCFG,
3924 "Chan %d Port 0x%06x handle 0x%x is dead (%d)",
3925 chan, portid, lp->handle, r);
3929 isp_pdb_add_update(isp, chan, &pdb);
3934 if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
3935 isp_prt(isp, ISP_LOG_SANCFG,
3936 "Chan %d Port 0x%06x is not logged in", chan, portid);
3940 r = isp_gff_id(isp, chan, portid);
3942 isp_prt(isp, ISP_LOG_SANCFG,
3943 "Chan %d Port 0x%06x is not an FCP target", chan, portid);
3947 r = isp_gft_id(isp, chan, portid);
3949 isp_prt(isp, ISP_LOG_SANCFG,
3950 "Chan %d Port 0x%06x is not FCP", chan, portid);
3954 if (isp_login_device(isp, chan, portid, &pdb,
3955 &FCPARAM(isp, 0)->isp_lasthdl)) {
3956 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3961 isp_pdb_add_update(isp, chan, &pdb);
3964 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3966 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3967 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan done", chan);
3972 * Find an unused handle and try and use to login to a port.
3975 isp_login_device(ispsoftc_t *isp, int chan, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)
3980 if (ISP_CAP_2KLOGIN(isp)) {
3986 handle = isp_next_handle(isp, ohp);
3987 for (i = 0; i < lim; i++) {
3988 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
3991 /* Check if this handle is free. */
3992 r = isp_getpdb(isp, chan, handle, p);
3994 if (p->portid != portid) {
3995 /* This handle is busy, try next one. */
3996 handle = isp_next_handle(isp, ohp);
4001 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
4005 * Now try and log into the device
4007 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
4010 } else if ((r & 0xffff) == MBOX_PORT_ID_USED) {
4012 * If we get here, then the firmwware still thinks we're logged into this device, but with a different
4013 * handle. We need to break that association. We used to try and just substitute the handle, but then
4014 * failed to get any data via isp_getpdb (below).
4016 if (isp_plogx(isp, chan, r >> 16, portid, PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT | PLOGX_FLG_FREE_NPHDL)) {
4017 isp_prt(isp, ISP_LOGERR, "baw... logout of %x failed", r >> 16);
4019 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
4021 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
4025 } else if ((r & 0xffff) == MBOX_LOOP_ID_USED) {
4026 /* Try the next handle. */
4027 handle = isp_next_handle(isp, ohp);
4036 isp_prt(isp, ISP_LOGWARN, "Chan %d PLOGI 0x%06x failed", chan, portid);
4041 * If we successfully logged into it, get the PDB for it
4042 * so we can crosscheck that it is still what we think it
4043 * is and that we also have the role it plays
4045 r = isp_getpdb(isp, chan, handle, p);
4047 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x disappeared", chan, portid, handle);
4051 if (p->handle != handle || p->portid != portid) {
4052 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
4053 chan, portid, handle, p->portid, p->handle);
4060 isp_send_change_request(ispsoftc_t *isp, int chan)
4064 MBSINIT(&mbs, MBOX_SEND_CHANGE_REQUEST, MBLOGALL, 500000);
4065 mbs.param[1] = 0x03;
4066 mbs.param[9] = chan;
4067 isp_mboxcmd(isp, &mbs);
4068 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
4071 isp_prt(isp, ISP_LOGWARN, "Chan %d Send Change Request: 0x%x",
4072 chan, mbs.param[0]);
4078 isp_register_fc4_type(ispsoftc_t *isp, int chan)
4080 fcparam *fcp = FCPARAM(isp, chan);
4082 ct_hdr_t *ct = &rp.rftid_hdr;
4083 uint8_t local[SNS_RFT_ID_REQ_SIZE];
4084 sns_screq_t *reqp = (sns_screq_t *) local;
4085 uint8_t *scp = fcp->isp_scratch;
4087 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4088 isp_prt(isp, ISP_LOGERR, sacq);
4093 /* Build the CT command and execute via pass-through. */
4094 ISP_MEMZERO(&rp, sizeof(rp));
4095 ct->ct_revision = CT_REVISION;
4096 ct->ct_fcs_type = CT_FC_TYPE_FC;
4097 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4098 ct->ct_cmd_resp = SNS_RFT_ID;
4099 ct->ct_bcnt_resid = (sizeof (rft_id_t) - sizeof (ct_hdr_t)) >> 2;
4100 rp.rftid_portid[0] = fcp->isp_portid >> 16;
4101 rp.rftid_portid[1] = fcp->isp_portid >> 8;
4102 rp.rftid_portid[2] = fcp->isp_portid;
4103 rp.rftid_fc4types[FC4_SCSI >> 5] = 1 << (FC4_SCSI & 0x1f);
4104 isp_put_rft_id(isp, &rp, (rft_id_t *)scp);
4106 if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
4107 FC_SCRATCH_RELEASE(isp, chan);
4111 /* Build the SNS request and execute via firmware. */
4112 ISP_MEMZERO((void *) reqp, SNS_RFT_ID_REQ_SIZE);
4113 reqp->snscb_rblen = sizeof (ct_hdr_t) >> 1;
4114 reqp->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma);
4115 reqp->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma);
4116 reqp->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma);
4117 reqp->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma);
4118 reqp->snscb_sblen = 22;
4119 reqp->snscb_data[0] = SNS_RFT_ID;
4120 reqp->snscb_data[4] = fcp->isp_portid & 0xffff;
4121 reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff;
4122 reqp->snscb_data[6] = (1 << FC4_SCSI);
4123 isp_put_sns_request(isp, reqp, (sns_screq_t *)scp);
4125 if (isp_ct_sns(isp, chan, SNS_RFT_ID_REQ_SIZE, sizeof(ct_hdr_t))) {
4126 FC_SCRATCH_RELEASE(isp, chan);
4131 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4132 FC_SCRATCH_RELEASE(isp, chan);
4133 if (ct->ct_cmd_resp == LS_RJT) {
4134 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "Chan %d Register FC4 Type rejected", chan);
4136 } else if (ct->ct_cmd_resp == LS_ACC) {
4137 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Register FC4 Type accepted", chan);
4139 isp_prt(isp, ISP_LOGWARN, "Chan %d Register FC4 Type: 0x%x", chan, ct->ct_cmd_resp);
4146 isp_register_fc4_features_24xx(ispsoftc_t *isp, int chan)
4148 fcparam *fcp = FCPARAM(isp, chan);
4151 uint8_t *scp = fcp->isp_scratch;
4153 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4154 isp_prt(isp, ISP_LOGERR, sacq);
4159 * Build the CT header and command in memory.
4161 ISP_MEMZERO(&rp, sizeof(rp));
4163 ct->ct_revision = CT_REVISION;
4164 ct->ct_fcs_type = CT_FC_TYPE_FC;
4165 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4166 ct->ct_cmd_resp = SNS_RFF_ID;
4167 ct->ct_bcnt_resid = (sizeof (rff_id_t) - sizeof (ct_hdr_t)) >> 2;
4168 rp.rffid_portid[0] = fcp->isp_portid >> 16;
4169 rp.rffid_portid[1] = fcp->isp_portid >> 8;
4170 rp.rffid_portid[2] = fcp->isp_portid;
4171 rp.rffid_fc4features = 0;
4172 if (fcp->role & ISP_ROLE_TARGET)
4173 rp.rffid_fc4features |= 1;
4174 if (fcp->role & ISP_ROLE_INITIATOR)
4175 rp.rffid_fc4features |= 2;
4176 rp.rffid_fc4type = FC4_SCSI;
4177 isp_put_rff_id(isp, &rp, (rff_id_t *)scp);
4178 if (isp->isp_dblev & ISP_LOGDEBUG1)
4179 isp_print_bytes(isp, "CT request", sizeof(rft_id_t), scp);
4181 if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
4182 FC_SCRATCH_RELEASE(isp, chan);
4186 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4187 FC_SCRATCH_RELEASE(isp, chan);
4188 if (ct->ct_cmd_resp == LS_RJT) {
4189 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4190 "Chan %d Register FC4 Features rejected", chan);
4192 } else if (ct->ct_cmd_resp == LS_ACC) {
4193 isp_prt(isp, ISP_LOG_SANCFG,
4194 "Chan %d Register FC4 Features accepted", chan);
4196 isp_prt(isp, ISP_LOGWARN,
4197 "Chan %d Register FC4 Features: 0x%x", chan, ct->ct_cmd_resp);
4204 isp_register_port_name_24xx(ispsoftc_t *isp, int chan)
4206 fcparam *fcp = FCPARAM(isp, chan);
4209 uint8_t *scp = fcp->isp_scratch;
4212 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4213 isp_prt(isp, ISP_LOGERR, sacq);
4218 * Build the CT header and command in memory.
4220 ISP_MEMZERO(&rp, sizeof(rp));
4221 ct = &rp.rspnid_hdr;
4222 ct->ct_revision = CT_REVISION;
4223 ct->ct_fcs_type = CT_FC_TYPE_FC;
4224 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4225 ct->ct_cmd_resp = SNS_RSPN_ID;
4226 rp.rspnid_portid[0] = fcp->isp_portid >> 16;
4227 rp.rspnid_portid[1] = fcp->isp_portid >> 8;
4228 rp.rspnid_portid[2] = fcp->isp_portid;
4229 rp.rspnid_length = 0;
4230 len = offsetof(rspn_id_t, rspnid_name);
4231 mtx_lock(&prison0.pr_mtx);
4232 rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
4233 "%s", prison0.pr_hostname[0] ? prison0.pr_hostname : "FreeBSD");
4234 mtx_unlock(&prison0.pr_mtx);
4235 rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
4236 ":%s", device_get_nameunit(isp->isp_dev));
4238 rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
4241 len += rp.rspnid_length;
4242 ct->ct_bcnt_resid = (len - sizeof(ct_hdr_t)) >> 2;
4243 isp_put_rspn_id(isp, &rp, (rspn_id_t *)scp);
4245 if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
4246 FC_SCRATCH_RELEASE(isp, chan);
4250 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4251 FC_SCRATCH_RELEASE(isp, chan);
4252 if (ct->ct_cmd_resp == LS_RJT) {
4253 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4254 "Chan %d Register Symbolic Port Name rejected", chan);
4256 } else if (ct->ct_cmd_resp == LS_ACC) {
4257 isp_prt(isp, ISP_LOG_SANCFG,
4258 "Chan %d Register Symbolic Port Name accepted", chan);
4260 isp_prt(isp, ISP_LOGWARN,
4261 "Chan %d Register Symbolic Port Name: 0x%x", chan, ct->ct_cmd_resp);
4268 isp_register_node_name_24xx(ispsoftc_t *isp, int chan)
4270 fcparam *fcp = FCPARAM(isp, chan);
4273 uint8_t *scp = fcp->isp_scratch;
4276 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4277 isp_prt(isp, ISP_LOGERR, sacq);
4282 * Build the CT header and command in memory.
4284 ISP_MEMZERO(&rp, sizeof(rp));
4285 ct = &rp.rsnnnn_hdr;
4286 ct->ct_revision = CT_REVISION;
4287 ct->ct_fcs_type = CT_FC_TYPE_FC;
4288 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4289 ct->ct_cmd_resp = SNS_RSNN_NN;
4290 MAKE_NODE_NAME_FROM_WWN(rp.rsnnnn_nodename, fcp->isp_wwnn);
4291 rp.rsnnnn_length = 0;
4292 len = offsetof(rsnn_nn_t, rsnnnn_name);
4293 mtx_lock(&prison0.pr_mtx);
4294 rp.rsnnnn_length += sprintf(&scp[len + rp.rsnnnn_length],
4295 "%s", prison0.pr_hostname[0] ? prison0.pr_hostname : "FreeBSD");
4296 mtx_unlock(&prison0.pr_mtx);
4297 len += rp.rsnnnn_length;
4298 ct->ct_bcnt_resid = (len - sizeof(ct_hdr_t)) >> 2;
4299 isp_put_rsnn_nn(isp, &rp, (rsnn_nn_t *)scp);
4301 if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
4302 FC_SCRATCH_RELEASE(isp, chan);
4306 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4307 FC_SCRATCH_RELEASE(isp, chan);
4308 if (ct->ct_cmd_resp == LS_RJT) {
4309 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4310 "Chan %d Register Symbolic Node Name rejected", chan);
4312 } else if (ct->ct_cmd_resp == LS_ACC) {
4313 isp_prt(isp, ISP_LOG_SANCFG,
4314 "Chan %d Register Symbolic Node Name accepted", chan);
4316 isp_prt(isp, ISP_LOGWARN,
4317 "Chan %d Register Symbolic Node Name: 0x%x", chan, ct->ct_cmd_resp);
4324 isp_next_handle(ispsoftc_t *isp, uint16_t *ohp)
4328 uint16_t handle, minh, maxh;
4331 if (ISP_CAP_2KLOGIN(isp)) {
4333 maxh = NPH_RESERVED - 1;
4341 if (handle == NIL_HANDLE) {
4345 if (handle > maxh) {
4347 isp_prt(isp, ISP_LOGERR, "Out of port handles!");
4348 return (NIL_HANDLE);
4353 for (chan = 0; chan < isp->isp_nchan; chan++) {
4354 fcp = FCPARAM(isp, chan);
4355 if (fcp->role == ISP_ROLE_NONE)
4357 for (i = 0; i < MAX_FC_TARG; i++) {
4358 if (fcp->portdb[i].state != FC_PORTDB_STATE_NIL &&
4359 fcp->portdb[i].handle == handle)
4368 * Start a command. Locking is assumed done in the caller.
4376 uint8_t local[QENTRY_LEN];
4381 int target, dmaresult;
4387 * Check command CDB length, etc.. We really are limited to 16 bytes
4388 * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
4389 * but probably only if we're running fairly new firmware (we'll
4390 * let the old f/w choke on an extended command queue entry).
4393 if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
4394 isp_prt(isp, ISP_LOGERR, "unsupported cdb length (%d, CDB[0]=0x%x)", XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
4395 XS_SETERR(xs, HBA_REQINVAL);
4396 return (CMD_COMPLETE);
4400 * Translate the target to device handle as appropriate, checking
4401 * for correct device state as well.
4403 target = XS_TGT(xs);
4405 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
4407 if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
4408 isp_prt(isp, ISP_LOG_WARN1,
4409 "%d.%d.%jx I am not an initiator",
4410 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4411 XS_SETERR(xs, HBA_SELTIMEOUT);
4412 return (CMD_COMPLETE);
4415 if (isp->isp_state != ISP_RUNSTATE) {
4416 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4417 XS_SETERR(xs, HBA_BOTCH);
4418 return (CMD_COMPLETE);
4421 isp_prt(isp, ISP_LOGDEBUG2, "XS_TGT(xs)=%d", target);
4422 lp = &fcp->portdb[target];
4423 if (target < 0 || target >= MAX_FC_TARG ||
4424 lp->is_target == 0) {
4425 XS_SETERR(xs, HBA_SELTIMEOUT);
4426 return (CMD_COMPLETE);
4428 if (fcp->isp_loopstate != LOOP_READY) {
4429 isp_prt(isp, ISP_LOGDEBUG1,
4430 "%d.%d.%jx loop is not ready",
4431 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4432 return (CMD_RQLATER);
4434 if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
4435 isp_prt(isp, ISP_LOGDEBUG1,
4436 "%d.%d.%jx target zombie",
4437 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4438 return (CMD_RQLATER);
4440 if (lp->state != FC_PORTDB_STATE_VALID) {
4441 isp_prt(isp, ISP_LOGDEBUG1,
4442 "%d.%d.%jx bad db port state 0x%x",
4443 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs), lp->state);
4444 XS_SETERR(xs, HBA_SELTIMEOUT);
4445 return (CMD_COMPLETE);
4448 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4449 if (isp->isp_state != ISP_RUNSTATE) {
4450 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4451 XS_SETERR(xs, HBA_BOTCH);
4452 return (CMD_COMPLETE);
4456 isp_spi_update(isp, XS_CHANNEL(xs));
4463 qep = isp_getrqentry(isp);
4465 isp_prt(isp, ISP_LOG_WARN1, "Request Queue Overflow");
4466 XS_SETERR(xs, HBA_BOTCH);
4467 return (CMD_EAGAIN);
4469 XS_SETERR(xs, HBA_NOERROR);
4472 * Now see if we need to synchronize the ISP with respect to anything.
4473 * We do dual duty here (cough) for synchronizing for buses other
4474 * than which we got here to send a command to.
4476 reqp = (ispreq_t *) local;
4477 ISP_MEMZERO(local, QENTRY_LEN);
4478 if (ISP_TST_SENDMARKER(isp, XS_CHANNEL(xs))) {
4480 isp_marker_24xx_t *m = (isp_marker_24xx_t *) reqp;
4481 m->mrk_header.rqs_entry_count = 1;
4482 m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4483 m->mrk_modifier = SYNC_ALL;
4484 m->mrk_vphdl = XS_CHANNEL(xs);
4485 isp_put_marker_24xx(isp, m, qep);
4487 isp_marker_t *m = (isp_marker_t *) reqp;
4488 m->mrk_header.rqs_entry_count = 1;
4489 m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4490 m->mrk_target = (XS_CHANNEL(xs) << 7); /* bus # */
4491 m->mrk_modifier = SYNC_ALL;
4492 isp_put_marker(isp, m, qep);
4494 ISP_SYNC_REQUEST(isp);
4495 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 0);
4499 reqp->req_header.rqs_entry_count = 1;
4502 * Select and install Header Code.
4503 * Note that it might be overridden before going out
4504 * if we're on a 64 bit platform. The lower level
4505 * code (isp_send_cmd) will select the appropriate
4506 * 64 bit variant if it needs to.
4509 reqp->req_header.rqs_entry_type = RQSTYPE_T7RQS;
4510 } else if (IS_FC(isp)) {
4511 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
4513 if (XS_CDBLEN(xs) > 12) {
4514 reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
4516 reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
4521 * Set task attributes
4526 ttype = XS_TAG_TYPE(xs);
4528 ttype = REQFLAG_STAG;
4530 if (ttype == REQFLAG_OTAG) {
4531 ttype = FCP_CMND_TASK_ATTR_ORDERED;
4532 } else if (ttype == REQFLAG_HTAG) {
4533 ttype = FCP_CMND_TASK_ATTR_HEAD;
4535 ttype = FCP_CMND_TASK_ATTR_SIMPLE;
4537 ((ispreqt7_t *)reqp)->req_task_attribute = ttype;
4538 } else if (IS_FC(isp)) {
4540 * See comment in isp_intr_respq
4542 /* XS_SET_RESID(xs, 0); */
4545 * Fibre Channel always requires some kind of tag.
4546 * The Qlogic drivers seem be happy not to use a tag,
4547 * but this breaks for some devices (IBM drives).
4550 ((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs);
4552 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_STAG;
4555 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4556 if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) && XS_TAG_P(xs)) {
4557 reqp->req_flags = XS_TAG_TYPE(xs);
4562 * NB: we do not support long CDBs (yet)
4564 cdblen = XS_CDBLEN(xs);
4567 if (cdblen > sizeof (reqp->req_cdb)) {
4568 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4569 XS_SETERR(xs, HBA_REQINVAL);
4570 return (CMD_COMPLETE);
4572 reqp->req_target = target | (XS_CHANNEL(xs) << 7);
4573 reqp->req_lun_trn = XS_LUN(xs);
4574 reqp->req_cdblen = cdblen;
4575 tptr = &reqp->req_time;
4576 cdbp = reqp->req_cdb;
4577 } else if (IS_24XX(isp)) {
4578 ispreqt7_t *t7 = (ispreqt7_t *)local;
4580 if (cdblen > sizeof (t7->req_cdb)) {
4581 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4582 XS_SETERR(xs, HBA_REQINVAL);
4583 return (CMD_COMPLETE);
4586 t7->req_nphdl = lp->handle;
4587 t7->req_tidlo = lp->portid;
4588 t7->req_tidhi = lp->portid >> 16;
4589 t7->req_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(xs));
4590 be64enc(t7->req_lun, CAM_EXTLUN_BYTE_SWIZZLE(XS_LUN(xs)));
4591 if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
4592 if (FCP_NEXT_CRN(isp, &t7->req_crn, xs)) {
4593 isp_prt(isp, ISP_LOG_WARN1,
4594 "%d.%d.%jx cannot generate next CRN",
4595 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4596 XS_SETERR(xs, HBA_BOTCH);
4597 return (CMD_EAGAIN);
4600 tptr = &t7->req_time;
4603 ispreqt2_t *t2 = (ispreqt2_t *)local;
4605 if (cdblen > sizeof t2->req_cdb) {
4606 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4607 XS_SETERR(xs, HBA_REQINVAL);
4608 return (CMD_COMPLETE);
4610 if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
4611 if (FCP_NEXT_CRN(isp, &t2->req_crn, xs)) {
4612 isp_prt(isp, ISP_LOG_WARN1,
4613 "%d.%d.%jx cannot generate next CRN",
4614 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4615 XS_SETERR(xs, HBA_BOTCH);
4616 return (CMD_EAGAIN);
4619 if (ISP_CAP_2KLOGIN(isp)) {
4620 ispreqt2e_t *t2e = (ispreqt2e_t *)local;
4621 t2e->req_target = lp->handle;
4622 t2e->req_scclun = XS_LUN(xs);
4623 tptr = &t2e->req_time;
4624 cdbp = t2e->req_cdb;
4625 } else if (ISP_CAP_SCCFW(isp)) {
4626 t2->req_target = lp->handle;
4627 t2->req_scclun = XS_LUN(xs);
4628 tptr = &t2->req_time;
4631 t2->req_target = lp->handle;
4632 t2->req_lun_trn = XS_LUN(xs);
4633 tptr = &t2->req_time;
4637 *tptr = XS_TIME(xs);
4638 ISP_MEMCPY(cdbp, XS_CDBP(xs), cdblen);
4640 /* Whew. Thankfully the same for type 7 requests */
4641 reqp->req_handle = isp_allocate_handle(isp, xs, ISP_HANDLE_INITIATOR);
4642 if (reqp->req_handle == 0) {
4643 isp_prt(isp, ISP_LOG_WARN1, "out of xflist pointers");
4644 XS_SETERR(xs, HBA_BOTCH);
4645 return (CMD_EAGAIN);
4649 * Set up DMA and/or do any platform dependent swizzling of the request entry
4650 * so that the Qlogic F/W understands what is being asked of it.
4652 * The callee is responsible for adding all requests at this point.
4654 dmaresult = ISP_DMASETUP(isp, xs, reqp);
4655 if (dmaresult != CMD_QUEUED) {
4656 isp_destroy_handle(isp, reqp->req_handle);
4658 * dmasetup sets actual error in packet, and
4659 * return what we were given to return.
4663 isp_xs_prt(isp, xs, ISP_LOGDEBUG0, "START cmd cdb[0]=0x%x datalen %ld", XS_CDBP(xs)[0], (long) XS_XFRLEN(xs));
4664 return (CMD_QUEUED);
4669 * Locks (ints blocked) assumed held.
4673 isp_control(ispsoftc_t *isp, ispctl_t ctl, ...)
4682 case ISPCTL_RESET_BUS:
4684 * Issue a bus reset.
4687 isp_prt(isp, ISP_LOGERR, "BUS RESET NOT IMPLEMENTED");
4689 } else if (IS_FC(isp)) {
4694 chan = va_arg(ap, int);
4696 mbs.param[1] = SDPARAM(isp, chan)->isp_bus_reset_delay;
4697 if (mbs.param[1] < 2) {
4700 mbs.param[2] = chan;
4702 MBSINIT(&mbs, MBOX_BUS_RESET, MBLOGALL, 0);
4703 ISP_SET_SENDMARKER(isp, chan, 1);
4704 isp_mboxcmd(isp, &mbs);
4705 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4708 isp_prt(isp, ISP_LOGINFO, "driver initiated bus reset of bus %d", chan);
4711 case ISPCTL_RESET_DEV:
4713 chan = va_arg(ap, int);
4714 tgt = va_arg(ap, int);
4717 uint8_t local[QENTRY_LEN];
4719 isp24xx_statusreq_t *sp;
4720 fcparam *fcp = FCPARAM(isp, chan);
4723 if (tgt < 0 || tgt >= MAX_FC_TARG) {
4724 isp_prt(isp, ISP_LOGWARN, "Chan %d trying to reset bad target %d", chan, tgt);
4727 lp = &fcp->portdb[tgt];
4728 if (lp->is_target == 0 ||
4729 lp->state != FC_PORTDB_STATE_VALID) {
4730 isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
4734 tmf = (isp24xx_tmf_t *) local;
4735 ISP_MEMZERO(tmf, QENTRY_LEN);
4736 tmf->tmf_header.rqs_entry_type = RQSTYPE_TSK_MGMT;
4737 tmf->tmf_header.rqs_entry_count = 1;
4738 tmf->tmf_nphdl = lp->handle;
4740 tmf->tmf_timeout = 4;
4741 tmf->tmf_flags = ISP24XX_TMF_TARGET_RESET;
4742 tmf->tmf_tidlo = lp->portid;
4743 tmf->tmf_tidhi = lp->portid >> 16;
4744 tmf->tmf_vpidx = ISP_GET_VPIDX(isp, chan);
4745 isp_put_24xx_tmf(isp, tmf, isp->isp_iocb);
4746 if (isp->isp_dblev & ISP_LOGDEBUG1)
4747 isp_print_bytes(isp, "TMF IOCB request", QENTRY_LEN, isp->isp_iocb);
4748 MEMORYBARRIER(isp, SYNC_IFORDEV, 0, QENTRY_LEN, chan);
4749 fcp->sendmarker = 1;
4751 isp_prt(isp, ISP_LOGALL, "Chan %d Reset N-Port Handle 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
4752 MBSINIT(&mbs, MBOX_EXEC_COMMAND_IOCB_A64, MBLOGALL,
4753 MBCMD_DEFAULT_TIMEOUT + tmf->tmf_timeout * 1000000);
4754 mbs.param[1] = QENTRY_LEN;
4755 mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
4756 mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
4757 mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
4758 mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
4759 isp_mboxcmd(isp, &mbs);
4760 if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
4763 MEMORYBARRIER(isp, SYNC_IFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
4764 if (isp->isp_dblev & ISP_LOGDEBUG1)
4765 isp_print_bytes(isp, "TMF IOCB response", QENTRY_LEN, &((isp24xx_statusreq_t *)isp->isp_iocb)[1]);
4766 sp = (isp24xx_statusreq_t *) local;
4767 isp_get_24xx_response(isp, &((isp24xx_statusreq_t *)isp->isp_iocb)[1], sp);
4768 if (sp->req_completion_status == 0) {
4771 isp_prt(isp, ISP_LOGWARN, "Chan %d reset of target %d returned 0x%x", chan, tgt, sp->req_completion_status);
4773 } else if (IS_FC(isp)) {
4774 if (ISP_CAP_2KLOGIN(isp)) {
4776 mbs.ibits = (1 << 10);
4778 mbs.param[1] = (tgt << 8);
4781 mbs.param[1] = (chan << 15) | (tgt << 8);
4783 MBSINIT(&mbs, MBOX_ABORT_TARGET, MBLOGALL, 0);
4784 mbs.param[2] = 3; /* 'delay', in seconds */
4785 isp_mboxcmd(isp, &mbs);
4786 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4789 isp_prt(isp, ISP_LOGINFO, "Target %d on Bus %d Reset Succeeded", tgt, chan);
4790 ISP_SET_SENDMARKER(isp, chan, 1);
4793 case ISPCTL_ABORT_CMD:
4795 xs = va_arg(ap, XS_T *);
4799 chan = XS_CHANNEL(xs);
4801 handle = isp_find_handle(isp, xs);
4803 isp_prt(isp, ISP_LOGWARN, "cannot find handle for command to abort");
4807 isp24xx_abrt_t local, *ab = &local;
4811 fcp = FCPARAM(isp, chan);
4812 if (tgt < 0 || tgt >= MAX_FC_TARG) {
4813 isp_prt(isp, ISP_LOGWARN, "Chan %d trying to abort bad target %d", chan, tgt);
4816 lp = &fcp->portdb[tgt];
4817 if (lp->is_target == 0 ||
4818 lp->state != FC_PORTDB_STATE_VALID) {
4819 isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
4822 isp_prt(isp, ISP_LOGALL, "Chan %d Abort Cmd for N-Port 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
4823 ISP_MEMZERO(ab, QENTRY_LEN);
4824 ab->abrt_header.rqs_entry_type = RQSTYPE_ABORT_IO;
4825 ab->abrt_header.rqs_entry_count = 1;
4826 ab->abrt_handle = lp->handle;
4827 ab->abrt_cmd_handle = handle;
4828 ab->abrt_tidlo = lp->portid;
4829 ab->abrt_tidhi = lp->portid >> 16;
4830 ab->abrt_vpidx = ISP_GET_VPIDX(isp, chan);
4831 isp_put_24xx_abrt(isp, ab, isp->isp_iocb);
4832 if (isp->isp_dblev & ISP_LOGDEBUG1)
4833 isp_print_bytes(isp, "AB IOCB quest", QENTRY_LEN, isp->isp_iocb);
4834 MEMORYBARRIER(isp, SYNC_IFORDEV, 0, 2 * QENTRY_LEN, chan);
4836 ISP_MEMZERO(&mbs, sizeof (mbs));
4837 MBSINIT(&mbs, MBOX_EXEC_COMMAND_IOCB_A64, MBLOGALL, 5000000);
4838 mbs.param[1] = QENTRY_LEN;
4839 mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
4840 mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
4841 mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
4842 mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
4844 isp_mboxcmd(isp, &mbs);
4845 if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
4848 MEMORYBARRIER(isp, SYNC_IFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
4849 if (isp->isp_dblev & ISP_LOGDEBUG1)
4850 isp_print_bytes(isp, "AB IOCB response", QENTRY_LEN, &((isp24xx_abrt_t *)isp->isp_iocb)[1]);
4851 isp_get_24xx_abrt(isp, &((isp24xx_abrt_t *)isp->isp_iocb)[1], ab);
4852 if (ab->abrt_nphdl == ISP24XX_ABRT_OKAY) {
4855 isp_prt(isp, ISP_LOGWARN, "Chan %d handle %d abort returned 0x%x", chan, tgt, ab->abrt_nphdl);
4857 } else if (IS_FC(isp)) {
4858 if (ISP_CAP_SCCFW(isp)) {
4859 if (ISP_CAP_2KLOGIN(isp)) {
4862 mbs.param[1] = tgt << 8;
4864 mbs.param[6] = XS_LUN(xs);
4866 mbs.param[1] = tgt << 8 | XS_LUN(xs);
4869 mbs.param[1] = (chan << 15) | (tgt << 8) | XS_LUN(xs);
4871 MBSINIT(&mbs, MBOX_ABORT,
4872 MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_ERROR), 0);
4873 mbs.param[2] = handle;
4874 isp_mboxcmd(isp, &mbs);
4875 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4880 case ISPCTL_UPDATE_PARAMS:
4883 chan = va_arg(ap, int);
4885 isp_spi_update(isp, chan);
4888 case ISPCTL_FCLINK_TEST:
4893 chan = va_arg(ap, int);
4894 usdelay = va_arg(ap, int);
4899 return (isp_fclink_test(isp, chan, usdelay));
4903 case ISPCTL_SCAN_FABRIC:
4907 chan = va_arg(ap, int);
4909 return (isp_scan_fabric(isp, chan));
4913 case ISPCTL_SCAN_LOOP:
4917 chan = va_arg(ap, int);
4919 return (isp_scan_loop(isp, chan));
4923 case ISPCTL_PDB_SYNC:
4927 chan = va_arg(ap, int);
4929 return (isp_pdb_sync(isp, chan));
4933 case ISPCTL_SEND_LIP:
4935 if (IS_FC(isp) && !IS_24XX(isp)) {
4936 MBSINIT(&mbs, MBOX_INIT_LIP, MBLOGALL, 0);
4937 if (ISP_CAP_2KLOGIN(isp)) {
4938 mbs.ibits = (1 << 10);
4940 isp_mboxcmd(isp, &mbs);
4941 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
4947 case ISPCTL_GET_PDB:
4951 chan = va_arg(ap, int);
4952 tgt = va_arg(ap, int);
4953 pdb = va_arg(ap, isp_pdb_t *);
4955 return (isp_getpdb(isp, chan, tgt, pdb));
4959 case ISPCTL_GET_NAMES:
4961 uint64_t *wwnn, *wwnp;
4963 chan = va_arg(ap, int);
4964 tgt = va_arg(ap, int);
4965 wwnn = va_arg(ap, uint64_t *);
4966 wwnp = va_arg(ap, uint64_t *);
4968 if (wwnn == NULL && wwnp == NULL) {
4972 *wwnn = isp_get_wwn(isp, chan, tgt, 1);
4973 if (*wwnn == INI_NONE) {
4978 *wwnp = isp_get_wwn(isp, chan, tgt, 0);
4979 if (*wwnp == INI_NONE) {
4985 case ISPCTL_RUN_MBOXCMD:
4988 mbr = va_arg(ap, mbreg_t *);
4990 isp_mboxcmd(isp, mbr);
4999 p = va_arg(ap, isp_plcmd_t *);
5002 if ((p->flags & PLOGX_FLG_CMD_MASK) != PLOGX_FLG_CMD_PLOGI || (p->handle != NIL_HANDLE)) {
5003 return (isp_plogx(isp, p->channel, p->handle, p->portid, p->flags));
5006 isp_next_handle(isp, &p->handle);
5007 r = isp_plogx(isp, p->channel, p->handle, p->portid, p->flags);
5008 if ((r & 0xffff) == MBOX_PORT_ID_USED) {
5009 p->handle = r >> 16;
5013 } while ((r & 0xffff) == MBOX_LOOP_ID_USED);
5016 case ISPCTL_CHANGE_ROLE:
5021 chan = va_arg(ap, int);
5022 role = va_arg(ap, int);
5024 r = isp_fc_change_role(isp, chan, role);
5029 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
5037 * Interrupt Service Routine(s).
5039 * External (OS) framework has done the appropriate locking,
5040 * and the locking will be held throughout this function.
5043 #ifdef ISP_TARGET_MODE
5045 isp_intr_atioq(ispsoftc_t *isp)
5047 uint8_t qe[QENTRY_LEN];
5050 uint32_t iptr, optr, oop;
5052 iptr = ISP_READ(isp, BIU2400_ATIO_RSPINP);
5053 optr = isp->isp_atioodx;
5054 while (optr != iptr) {
5056 MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN, -1);
5057 addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
5058 isp_get_hdr(isp, addr, (isphdr_t *)qe);
5059 hp = (isphdr_t *)qe;
5060 switch (hp->rqs_entry_type) {
5061 case RQSTYPE_NOTIFY:
5063 (void) isp_target_notify(isp, addr, &oop);
5066 isp_print_qentry(isp, "?ATIOQ entry?", oop, addr);
5069 optr = ISP_NXT_QENTRY(oop, RESULT_QUEUE_LEN(isp));
5071 if (isp->isp_atioodx != optr) {
5072 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, optr);
5073 isp->isp_atioodx = optr;
5079 isp_intr_async(ispsoftc_t *isp, uint16_t event)
5083 isp_parse_async_fc(isp, event);
5085 isp_parse_async(isp, event);
5089 isp_intr_mbox(ispsoftc_t *isp, uint16_t mbox0)
5093 if (!isp->isp_mboxbsy) {
5094 isp_prt(isp, ISP_LOGWARN, "mailbox 0x%x with no waiters", mbox0);
5097 obits = isp->isp_obits;
5098 isp->isp_mboxtmp[0] = mbox0;
5099 for (i = 1; i < ISP_NMBOX(isp); i++) {
5100 if ((obits & (1 << i)) == 0)
5102 isp->isp_mboxtmp[i] = ISP_READ(isp, MBOX_OFF(i));
5104 MBOX_NOTIFY_COMPLETE(isp);
5108 isp_intr_respq(ispsoftc_t *isp)
5111 uint8_t qe[QENTRY_LEN];
5112 ispstatusreq_t *sp = (ispstatusreq_t *)qe;
5113 isp24xx_statusreq_t *sp2 = (isp24xx_statusreq_t *)qe;
5115 uint8_t *resp, *snsp;
5116 int buddaboom, completion_status, cont = 0, etype, i;
5117 int req_status_flags, req_state_flags, scsi_status;
5118 uint32_t iptr, junk, cptr, optr, rlen, slen, sptr, totslen, resid;
5121 * We can't be getting this now.
5123 if (isp->isp_state != ISP_RUNSTATE) {
5124 isp_prt(isp, ISP_LOGINFO, "respq interrupt when not ready");
5128 iptr = ISP_READ(isp, isp->isp_respinrp);
5129 /* Debounce the 2300 if revision less than 2. */
5130 if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
5133 iptr = ISP_READ(isp, isp->isp_respinrp);
5134 } while (junk != iptr);
5136 isp->isp_residx = iptr;
5138 optr = isp->isp_resodx;
5139 while (optr != iptr) {
5141 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, cptr);
5142 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
5145 * Synchronize our view of this response queue entry.
5147 MEMORYBARRIER(isp, SYNC_RESULT, cptr, QENTRY_LEN, -1);
5148 if (isp->isp_dblev & ISP_LOGDEBUG1)
5149 isp_print_qentry(isp, "Response Queue Entry", cptr, hp);
5150 isp_get_hdr(isp, hp, &sp->req_header);
5151 etype = sp->req_header.rqs_entry_type;
5153 /* We expected Status Continuation, but got different IOCB. */
5154 if (cont > 0 && etype != RQSTYPE_STATUS_CONT) {
5159 if (IS_24XX(isp) && etype == RQSTYPE_RESPONSE) {
5160 isp_get_24xx_response(isp, (isp24xx_statusreq_t *)hp, sp2);
5161 scsi_status = sp2->req_scsi_status;
5162 completion_status = sp2->req_completion_status;
5163 req_status_flags = 0;
5164 if ((scsi_status & 0xff) != 0)
5165 req_state_flags = RQSF_GOT_STATUS;
5167 req_state_flags = 0;
5168 resid = sp2->req_resid;
5169 } else if (etype == RQSTYPE_RESPONSE) {
5170 isp_get_response(isp, (ispstatusreq_t *) hp, sp);
5171 scsi_status = sp->req_scsi_status;
5172 completion_status = sp->req_completion_status;
5173 req_status_flags = sp->req_status_flags;
5174 req_state_flags = sp->req_state_flags;
5175 resid = sp->req_resid;
5176 } else if (etype == RQSTYPE_RIO1) {
5177 isp_rio1_t *rio = (isp_rio1_t *) qe;
5178 isp_get_rio1(isp, (isp_rio1_t *) hp, rio);
5179 for (i = 0; i < rio->req_header.rqs_seqno; i++) {
5180 isp_fastpost_complete(isp, rio->req_handles[i]);
5182 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5184 } else if (etype == RQSTYPE_RIO2) {
5185 isp_prt(isp, ISP_LOGERR, "dropping RIO2 response");
5186 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5188 } else if (etype == RQSTYPE_STATUS_CONT) {
5189 ispstatus_cont_t *scp = (ispstatus_cont_t *)qe;
5190 isp_get_cont_response(isp, (ispstatus_cont_t *)hp, scp);
5192 i = min(cont, sizeof(scp->req_sense_data));
5193 XS_SENSE_APPEND(cont_xs, scp->req_sense_data, i);
5198 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
5199 "Expecting Status Continuations for %u bytes",
5203 isp_prt(isp, ISP_LOG_WARN1, "Ignored Continuation Response");
5205 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5207 } else if (isp_handle_other_response(isp, etype, hp, &cptr)) {
5208 /* More then one IOCB could be consumed. */
5209 while (sptr != cptr) {
5210 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5211 sptr = ISP_NXT_QENTRY(sptr, RESULT_QUEUE_LEN(isp));
5212 hp = (isphdr_t *)ISP_QUEUE_ENTRY(isp->isp_result, sptr);
5214 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5215 optr = ISP_NXT_QENTRY(cptr, RESULT_QUEUE_LEN(isp));
5218 /* We don't know what was this -- log and skip. */
5219 isp_prt(isp, ISP_LOGERR, notresp, etype, cptr, optr);
5220 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5225 if (sp->req_header.rqs_flags & RQSFLAG_MASK) {
5226 if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
5227 isp_print_qentry(isp, "unexpected continuation segment",
5231 if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
5232 isp_prt(isp, ISP_LOG_WARN1, "internal queues full");
5234 * We'll synthesize a QUEUE FULL message below.
5237 if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
5238 isp_print_qentry(isp, "bad header flag",
5242 if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
5243 isp_print_qentry(isp, "bad request packet",
5247 if (sp->req_header.rqs_flags & RQSFLAG_BADCOUNT) {
5248 isp_print_qentry(isp, "invalid entry count",
5252 if (sp->req_header.rqs_flags & RQSFLAG_BADORDER) {
5253 isp_print_qentry(isp, "invalid IOCB ordering",
5259 xs = isp_find_xs(isp, sp->req_handle);
5261 uint8_t ts = completion_status & 0xff;
5263 * Only whine if this isn't the expected fallout of
5264 * aborting the command or resetting the target.
5266 if (etype != RQSTYPE_RESPONSE) {
5267 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (type 0x%x)", sp->req_handle, etype);
5268 } else if (ts != RQCS_ABORTED && ts != RQCS_RESET_OCCURRED) {
5269 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (status 0x%x)", sp->req_handle, ts);
5271 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5274 if (req_status_flags & RQSTF_BUS_RESET) {
5275 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%jx bus was reset",
5276 XS_CHANNEL(xs), XS_TGT(xs), (uintmax_t)XS_LUN(xs));
5277 XS_SETERR(xs, HBA_BUSRESET);
5278 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
5281 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%jx buddaboom",
5282 XS_CHANNEL(xs), XS_TGT(xs), (uintmax_t)XS_LUN(xs));
5283 XS_SETERR(xs, HBA_BOTCH);
5287 rlen = slen = totslen = 0;
5288 if (IS_24XX(isp) && (scsi_status & (RQCS_RV|RQCS_SV)) != 0) {
5289 resp = sp2->req_rsp_sense;
5290 rlen = sp2->req_response_len;
5291 } else if (IS_FC(isp) && (scsi_status & RQCS_RV) != 0) {
5292 resp = sp->req_response;
5293 rlen = sp->req_response_len;
5295 if (IS_FC(isp) && (scsi_status & RQCS_SV) != 0) {
5297 * Fibre Channel F/W doesn't say we got status
5298 * if there's Sense Data instead. I guess they
5299 * think it goes w/o saying.
5301 req_state_flags |= RQSF_GOT_STATUS|RQSF_GOT_SENSE;
5303 snsp = sp2->req_rsp_sense;
5305 totslen = sp2->req_sense_len;
5306 slen = sizeof(sp2->req_rsp_sense) - rlen;
5308 snsp = sp->req_sense_data;
5309 totslen = sp->req_sense_len;
5310 slen = sizeof(sp->req_sense_data);
5312 } else if (IS_SCSI(isp) && (req_state_flags & RQSF_GOT_SENSE)) {
5313 snsp = sp->req_sense_data;
5314 totslen = sp->req_sense_len;
5315 slen = sizeof (sp->req_sense_data);
5319 if (req_state_flags & RQSF_GOT_STATUS)
5320 *XS_STSP(xs) = scsi_status & 0xff;
5322 if (rlen >= 4 && resp[FCP_RSPNS_CODE_OFFSET] != 0) {
5325 const char *rnames[10] = {
5326 "Task Management function complete",
5327 "FCP_DATA length different than FCP_BURST_LEN",
5328 "FCP_CMND fields invalid",
5329 "FCP_DATA parameter mismatch with FCP_DATA_RO",
5330 "Task Management function rejected",
5331 "Task Management function failed",
5334 "Task Management function succeeded",
5335 "Task Management function incorrect logical unit number",
5337 uint8_t code = resp[FCP_RSPNS_CODE_OFFSET];
5338 if (code >= 10 || rnames[code] == NULL) {
5339 ISP_SNPRINTF(lb, sizeof(lb),
5340 "Unknown FCP Response Code 0x%x", code);
5345 isp_xs_prt(isp, xs, ISP_LOGWARN,
5346 "FCP RESPONSE, LENGTH %u: %s CDB0=0x%02x",
5347 rlen, ptr, XS_CDBP(xs)[0] & 0xff);
5348 if (code != 0 && code != 8)
5349 XS_SETERR(xs, HBA_BOTCH);
5352 isp_parse_status_24xx(isp, sp2, xs, &resid);
5354 isp_parse_status(isp, sp, xs, &resid);
5355 if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
5356 (*XS_STSP(xs) == SCSI_BUSY))
5357 XS_SETERR(xs, HBA_TGTBSY);
5359 XS_SET_RESID(xs, resid);
5361 * A new synchronous rate was negotiated for
5362 * this target. Mark state such that we'll go
5363 * look up that which has changed later.
5365 if (req_status_flags & RQSTF_NEGOTIATION) {
5367 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
5368 sdp->isp_devparam[t].dev_refresh = 1;
5372 if (req_status_flags & RQSF_XFER_COMPLETE) {
5373 XS_SET_RESID(xs, 0);
5374 } else if (scsi_status & RQCS_RESID) {
5375 XS_SET_RESID(xs, resid);
5377 XS_SET_RESID(xs, 0);
5381 XS_SAVE_SENSE(xs, snsp, slen);
5382 if (totslen > slen) {
5383 cont = totslen - slen;
5385 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
5386 "Expecting Status Continuations for %u bytes",
5390 isp_prt(isp, ISP_LOGDEBUG2, "asked for %lu got raw resid %lu settled for %lu",
5391 (u_long)XS_XFRLEN(xs), (u_long)resid, (u_long)XS_GET_RESID(xs));
5394 ISP_DMAFREE(isp, xs, sp->req_handle);
5395 isp_destroy_handle(isp, sp->req_handle);
5397 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5399 /* Complete command if we expect no Status Continuations. */
5404 /* We haven't received all Status Continuations, but that is it. */
5408 /* If we processed any IOCBs, let ISP know about it. */
5409 if (optr != isp->isp_resodx) {
5410 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5411 isp->isp_resodx = optr;
5416 * Parse an ASYNC mailbox complete
5419 isp_parse_async(ispsoftc_t *isp, uint16_t mbox)
5421 uint32_t h1 = 0, h2 = 0;
5425 * Pick up the channel, but not if this is a ASYNC_RIO32_2,
5426 * where Mailboxes 6/7 have the second handle.
5428 if (mbox != ASYNC_RIO32_2) {
5429 if (IS_DUALBUS(isp)) {
5430 chan = ISP_READ(isp, OUTMAILBOX6);
5433 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5436 case ASYNC_BUS_RESET:
5437 ISP_SET_SENDMARKER(isp, chan, 1);
5438 #ifdef ISP_TARGET_MODE
5439 isp_target_async(isp, chan, mbox);
5441 isp_async(isp, ISPASYNC_BUS_RESET, chan);
5443 case ASYNC_SYSTEM_ERROR:
5444 isp->isp_state = ISP_CRASHED;
5446 * Were we waiting for a mailbox command to complete?
5447 * If so, it's dead, so wake up the waiter.
5449 if (isp->isp_mboxbsy) {
5451 isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5452 MBOX_NOTIFY_COMPLETE(isp);
5455 * It's up to the handler for isp_async to reinit stuff and
5456 * restart the firmware
5458 isp_async(isp, ISPASYNC_FW_CRASH);
5461 case ASYNC_RQS_XFER_ERR:
5462 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5465 case ASYNC_RSP_XFER_ERR:
5466 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5471 * We've just been notified that the Queue has woken up.
5472 * We don't need to be chatty about this- just unlatch things
5475 mbox = ISP_READ(isp, isp->isp_rqstoutrp);
5478 case ASYNC_TIMEOUT_RESET:
5479 isp_prt(isp, ISP_LOGWARN, "timeout initiated SCSI bus reset of chan %d", chan);
5480 ISP_SET_SENDMARKER(isp, chan, 1);
5481 #ifdef ISP_TARGET_MODE
5482 isp_target_async(isp, chan, mbox);
5486 case ASYNC_DEVICE_RESET:
5487 isp_prt(isp, ISP_LOGINFO, "device reset on chan %d", chan);
5488 ISP_SET_SENDMARKER(isp, chan, 1);
5489 #ifdef ISP_TARGET_MODE
5490 isp_target_async(isp, chan, mbox);
5494 case ASYNC_EXTMSG_UNDERRUN:
5495 isp_prt(isp, ISP_LOGWARN, "extended message underrun");
5498 case ASYNC_SCAM_INT:
5499 isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
5502 case ASYNC_HUNG_SCSI:
5503 isp_prt(isp, ISP_LOGERR, "stalled SCSI Bus after DATA Overrun");
5504 /* XXX: Need to issue SCSI reset at this point */
5507 case ASYNC_KILLED_BUS:
5508 isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
5511 case ASYNC_BUS_TRANSIT:
5512 mbox = ISP_READ(isp, OUTMAILBOX2);
5513 switch (mbox & SXP_PINS_MODE_MASK) {
5514 case SXP_PINS_LVD_MODE:
5515 isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
5516 SDPARAM(isp, chan)->isp_diffmode = 0;
5517 SDPARAM(isp, chan)->isp_ultramode = 0;
5518 SDPARAM(isp, chan)->isp_lvdmode = 1;
5520 case SXP_PINS_HVD_MODE:
5521 isp_prt(isp, ISP_LOGINFO,
5522 "Transition to Differential mode");
5523 SDPARAM(isp, chan)->isp_diffmode = 1;
5524 SDPARAM(isp, chan)->isp_ultramode = 0;
5525 SDPARAM(isp, chan)->isp_lvdmode = 0;
5527 case SXP_PINS_SE_MODE:
5528 isp_prt(isp, ISP_LOGINFO,
5529 "Transition to Single Ended mode");
5530 SDPARAM(isp, chan)->isp_diffmode = 0;
5531 SDPARAM(isp, chan)->isp_ultramode = 1;
5532 SDPARAM(isp, chan)->isp_lvdmode = 0;
5535 isp_prt(isp, ISP_LOGWARN,
5536 "Transition to Unknown Mode 0x%x", mbox);
5540 * XXX: Set up to renegotiate again!
5542 /* Can only be for a 1080... */
5543 ISP_SET_SENDMARKER(isp, chan, 1);
5546 case ASYNC_CMD_CMPLT:
5548 if (!IS_ULTRA3(isp)) {
5549 isp_prt(isp, ISP_LOGERR, "unexpected fast posting completion");
5553 h1 = (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1);
5557 h1 = (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1);
5558 h2 = (ISP_READ(isp, OUTMAILBOX7) << 16) | ISP_READ(isp, OUTMAILBOX6);
5566 isp_prt(isp, ISP_LOGERR, "unexpected 16 bit RIO handle");
5569 isp_prt(isp, ISP_LOGWARN, "%s: unhandled async code 0x%x", __func__, mbox);
5574 isp_prt(isp, ISP_LOGDEBUG3, "fast post/rio completion of 0x%08x", h1);
5575 isp_fastpost_complete(isp, h1);
5577 isp_prt(isp, ISP_LOGDEBUG3, "fast post/rio completion of 0x%08x", h2);
5578 isp_fastpost_complete(isp, h2);
5584 isp_parse_async_fc(ispsoftc_t *isp, uint16_t mbox)
5589 if (IS_DUALBUS(isp)) {
5590 chan = ISP_READ(isp, OUTMAILBOX6);
5594 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5597 case ASYNC_SYSTEM_ERROR:
5598 isp->isp_state = ISP_CRASHED;
5599 FCPARAM(isp, chan)->isp_loopstate = LOOP_NIL;
5600 isp_change_fw_state(isp, chan, FW_CONFIG_WAIT);
5602 * Were we waiting for a mailbox command to complete?
5603 * If so, it's dead, so wake up the waiter.
5605 if (isp->isp_mboxbsy) {
5607 isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5608 MBOX_NOTIFY_COMPLETE(isp);
5611 * It's up to the handler for isp_async to reinit stuff and
5612 * restart the firmware
5614 isp_async(isp, ISPASYNC_FW_CRASH);
5617 case ASYNC_RQS_XFER_ERR:
5618 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5621 case ASYNC_RSP_XFER_ERR:
5622 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5626 #ifdef ISP_TARGET_MODE
5628 isp_prt(isp, ISP_LOGERR, "ATIO Queue Transfer Error");
5632 isp_prt(isp, ISP_LOGERR, "%s: unexpected ASYNC_QWAKEUP code", __func__);
5635 case ASYNC_CMD_CMPLT:
5636 isp_fastpost_complete(isp, (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1));
5639 case ASYNC_RIOZIO_STALL:
5640 isp_intr_respq(isp);
5643 case ASYNC_CTIO_DONE:
5644 #ifdef ISP_TARGET_MODE
5645 isp_target_async(isp, (ISP_READ(isp, OUTMAILBOX2) << 16) |
5646 ISP_READ(isp, OUTMAILBOX1), mbox);
5648 isp_prt(isp, ISP_LOGWARN, "unexpected ASYNC CTIO done");
5651 case ASYNC_LIP_ERROR:
5652 case ASYNC_LIP_NOS_OLS_RECV:
5653 case ASYNC_LIP_OCCURRED:
5656 * These are broadcast events that have to be sent across
5657 * all active channels.
5659 for (chan = 0; chan < isp->isp_nchan; chan++) {
5660 fcp = FCPARAM(isp, chan);
5661 int topo = fcp->isp_topo;
5663 if (fcp->role == ISP_ROLE_NONE)
5665 if (fcp->isp_loopstate > LOOP_HAVE_LINK)
5666 fcp->isp_loopstate = LOOP_HAVE_LINK;
5667 ISP_SET_SENDMARKER(isp, chan, 1);
5668 isp_async(isp, ISPASYNC_LIP, chan);
5669 #ifdef ISP_TARGET_MODE
5670 isp_target_async(isp, chan, mbox);
5673 * We've had problems with data corruption occurring on
5674 * commands that complete (with no apparent error) after
5675 * we receive a LIP. This has been observed mostly on
5676 * Local Loop topologies. To be safe, let's just mark
5677 * all active initiator commands as dead.
5679 if (topo == TOPO_NL_PORT || topo == TOPO_FL_PORT) {
5681 for (i = j = 0; i < isp->isp_maxcmds; i++) {
5685 hdp = &isp->isp_xflist[i];
5686 if (ISP_H2HT(hdp->handle) != ISP_HANDLE_INITIATOR) {
5690 if (XS_CHANNEL(xs) != chan) {
5694 isp_prt(isp, ISP_LOG_WARN1,
5695 "%d.%d.%jx bus reset set at %s:%u",
5696 XS_CHANNEL(xs), XS_TGT(xs),
5697 (uintmax_t)XS_LUN(xs),
5698 __func__, __LINE__);
5699 XS_SETERR(xs, HBA_BUSRESET);
5702 isp_prt(isp, ISP_LOGERR, lipd, chan, j);
5710 * This is a broadcast event that has to be sent across
5711 * all active channels.
5713 for (chan = 0; chan < isp->isp_nchan; chan++) {
5714 fcp = FCPARAM(isp, chan);
5715 if (fcp->role == ISP_ROLE_NONE)
5717 fcp->isp_linkstate = 1;
5718 if (fcp->isp_loopstate < LOOP_HAVE_LINK)
5719 fcp->isp_loopstate = LOOP_HAVE_LINK;
5720 ISP_SET_SENDMARKER(isp, chan, 1);
5721 isp_async(isp, ISPASYNC_LOOP_UP, chan);
5722 #ifdef ISP_TARGET_MODE
5723 isp_target_async(isp, chan, mbox);
5728 case ASYNC_LOOP_DOWN:
5730 * This is a broadcast event that has to be sent across
5731 * all active channels.
5733 for (chan = 0; chan < isp->isp_nchan; chan++) {
5734 fcp = FCPARAM(isp, chan);
5735 if (fcp->role == ISP_ROLE_NONE)
5737 ISP_SET_SENDMARKER(isp, chan, 1);
5738 fcp->isp_linkstate = 0;
5739 fcp->isp_loopstate = LOOP_NIL;
5740 isp_async(isp, ISPASYNC_LOOP_DOWN, chan);
5741 #ifdef ISP_TARGET_MODE
5742 isp_target_async(isp, chan, mbox);
5747 case ASYNC_LOOP_RESET:
5749 * This is a broadcast event that has to be sent across
5750 * all active channels.
5752 for (chan = 0; chan < isp->isp_nchan; chan++) {
5753 fcp = FCPARAM(isp, chan);
5754 if (fcp->role == ISP_ROLE_NONE)
5756 ISP_SET_SENDMARKER(isp, chan, 1);
5757 if (fcp->isp_loopstate > LOOP_HAVE_LINK)
5758 fcp->isp_loopstate = LOOP_HAVE_LINK;
5759 isp_async(isp, ISPASYNC_LOOP_RESET, chan);
5760 #ifdef ISP_TARGET_MODE
5761 isp_target_async(isp, chan, mbox);
5766 case ASYNC_PDB_CHANGED:
5768 int echan, nphdl, nlstate, reason;
5770 if (IS_23XX(isp) || IS_24XX(isp)) {
5771 nphdl = ISP_READ(isp, OUTMAILBOX1);
5772 nlstate = ISP_READ(isp, OUTMAILBOX2);
5774 nphdl = nlstate = 0xffff;
5777 reason = ISP_READ(isp, OUTMAILBOX3) >> 8;
5780 if (ISP_CAP_MULTI_ID(isp)) {
5781 chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
5782 if (chan == 0xff || nphdl == NIL_HANDLE) {
5784 echan = isp->isp_nchan - 1;
5785 } else if (chan >= isp->isp_nchan) {
5793 for (; chan <= echan; chan++) {
5794 fcp = FCPARAM(isp, chan);
5795 if (fcp->role == ISP_ROLE_NONE)
5797 if (fcp->isp_loopstate > LOOP_LTEST_DONE) {
5798 if (nphdl != NIL_HANDLE &&
5799 nphdl == fcp->isp_login_hdl &&
5800 reason == PDB24XX_AE_OPN_2)
5802 fcp->isp_loopstate = LOOP_LTEST_DONE;
5803 } else if (fcp->isp_loopstate < LOOP_HAVE_LINK)
5804 fcp->isp_loopstate = LOOP_HAVE_LINK;
5805 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
5806 ISPASYNC_CHANGE_PDB, nphdl, nlstate, reason);
5810 case ASYNC_CHANGE_NOTIFY:
5814 portid = ((ISP_READ(isp, OUTMAILBOX1) & 0xff) << 16) |
5815 ISP_READ(isp, OUTMAILBOX2);
5816 if (ISP_CAP_MULTI_ID(isp)) {
5817 chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
5818 if (chan >= isp->isp_nchan)
5823 fcp = FCPARAM(isp, chan);
5824 if (fcp->role == ISP_ROLE_NONE)
5826 if (fcp->isp_loopstate > LOOP_LTEST_DONE)
5827 fcp->isp_loopstate = LOOP_LTEST_DONE;
5828 else if (fcp->isp_loopstate < LOOP_HAVE_LINK)
5829 fcp->isp_loopstate = LOOP_HAVE_LINK;
5830 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
5831 ISPASYNC_CHANGE_SNS, portid);
5834 case ASYNC_ERR_LOGGING_DISABLED:
5835 isp_prt(isp, ISP_LOGWARN, "Error logging disabled (reason 0x%x)",
5836 ISP_READ(isp, OUTMAILBOX1));
5838 case ASYNC_CONNMODE:
5840 * This only applies to 2100 amd 2200 cards
5842 if (!IS_2200(isp) && !IS_2100(isp)) {
5843 isp_prt(isp, ISP_LOGWARN, "bad card for ASYNC_CONNMODE event");
5847 mbox = ISP_READ(isp, OUTMAILBOX1);
5850 isp_prt(isp, ISP_LOGINFO,
5851 "Point-to-Point -> Loop mode");
5854 isp_prt(isp, ISP_LOGINFO,
5855 "Loop -> Point-to-Point mode");
5857 case ISP_CONN_BADLIP:
5858 isp_prt(isp, ISP_LOGWARN,
5859 "Point-to-Point -> Loop mode (BAD LIP)");
5861 case ISP_CONN_FATAL:
5862 isp->isp_state = ISP_CRASHED;
5863 isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
5864 isp_async(isp, ISPASYNC_FW_CRASH);
5866 case ISP_CONN_LOOPBACK:
5867 isp_prt(isp, ISP_LOGWARN,
5868 "Looped Back in Point-to-Point mode");
5871 isp_prt(isp, ISP_LOGWARN,
5872 "Unknown connection mode (0x%x)", mbox);
5875 ISP_SET_SENDMARKER(isp, chan, 1);
5876 FCPARAM(isp, chan)->isp_loopstate = LOOP_HAVE_LINK;
5877 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan, ISPASYNC_CHANGE_OTHER);
5879 case ASYNC_P2P_INIT_ERR:
5880 isp_prt(isp, ISP_LOGWARN, "P2P init error (reason 0x%x)",
5881 ISP_READ(isp, OUTMAILBOX1));
5885 isp_prt(isp, ISP_LOGWARN, "Receive Error");
5887 isp_prt(isp, ISP_LOGWARN, "unexpected ASYNC_RCV_ERR");
5890 case ASYNC_RJT_SENT: /* same as ASYNC_QFULL_SENT */
5892 isp_prt(isp, ISP_LOGTDEBUG0, "LS_RJT sent");
5895 isp_prt(isp, ISP_LOGTDEBUG0, "QFULL sent");
5898 case ASYNC_FW_RESTART_COMPLETE:
5899 isp_prt(isp, ISP_LOGDEBUG0, "FW restart complete");
5901 case ASYNC_TEMPERATURE_ALERT:
5902 isp_prt(isp, ISP_LOGERR, "Temperature alert (subcode 0x%x)",
5903 ISP_READ(isp, OUTMAILBOX1));
5905 case ASYNC_AUTOLOAD_FW_COMPLETE:
5906 isp_prt(isp, ISP_LOGDEBUG0, "Autoload FW init complete");
5908 case ASYNC_AUTOLOAD_FW_FAILURE:
5909 isp_prt(isp, ISP_LOGERR, "Autoload FW init failure");
5912 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
5918 * Handle other response entries. A pointer to the request queue output
5919 * index is here in case we want to eat several entries at once, although
5920 * this is not used currently.
5924 isp_handle_other_response(ispsoftc_t *isp, int type, isphdr_t *hp, uint32_t *optrp)
5928 uint32_t hdl, portid;
5932 case RQSTYPE_MARKER:
5933 isp_prt(isp, ISP_LOG_WARN1, "Marker Response");
5935 case RQSTYPE_RPT_ID_ACQ:
5936 isp_get_ridacq(isp, (isp_ridacq_t *)hp, &rid);
5937 portid = (uint32_t)rid.ridacq_vp_port_hi << 16 |
5938 rid.ridacq_vp_port_lo;
5939 if (rid.ridacq_format == 0) {
5940 for (chan = 0; chan < isp->isp_nchan; chan++) {
5941 fcparam *fcp = FCPARAM(isp, chan);
5942 if (fcp->role == ISP_ROLE_NONE)
5944 c = (chan == 0) ? 127 : (chan - 1);
5945 if (rid.ridacq_map[c / 16] & (1 << (c % 16)) ||
5947 fcp->isp_loopstate = LOOP_HAVE_LINK;
5948 isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
5949 chan, ISPASYNC_CHANGE_OTHER);
5951 fcp->isp_loopstate = LOOP_NIL;
5952 isp_async(isp, ISPASYNC_LOOP_DOWN,
5957 fcparam *fcp = FCPARAM(isp, rid.ridacq_vp_index);
5958 if (rid.ridacq_vp_status == RIDACQ_STS_COMPLETE ||
5959 rid.ridacq_vp_status == RIDACQ_STS_CHANGED) {
5960 fcp->isp_topo = (rid.ridacq_map[0] >> 9) & 0x7;
5961 fcp->isp_portid = portid;
5962 fcp->isp_loopstate = LOOP_HAVE_ADDR;
5963 isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
5964 rid.ridacq_vp_index, ISPASYNC_CHANGE_OTHER);
5966 fcp->isp_loopstate = LOOP_NIL;
5967 isp_async(isp, ISPASYNC_LOOP_DOWN,
5968 rid.ridacq_vp_index);
5972 case RQSTYPE_CT_PASSTHRU:
5973 case RQSTYPE_VP_MODIFY:
5974 case RQSTYPE_VP_CTRL:
5976 ISP_IOXGET_32(isp, (uint32_t *)(hp + 1), hdl);
5977 ptr = isp_find_xs(isp, hdl);
5979 isp_destroy_handle(isp, hdl);
5980 memcpy(ptr, hp, QENTRY_LEN);
5986 case RQSTYPE_NOTIFY:
5987 case RQSTYPE_NOTIFY_ACK:
5993 case RQSTYPE_ABTS_RCVD:
5994 case RQSTYPE_ABTS_RSP:
5995 #ifdef ISP_TARGET_MODE
5996 return (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp));
5999 case RQSTYPE_REQUEST:
6006 isp_parse_status(ispsoftc_t *isp, ispstatusreq_t *sp, XS_T *xs, uint32_t *rp)
6008 switch (sp->req_completion_status & 0xff) {
6011 XS_SETERR(xs, HBA_NOERROR);
6015 case RQCS_INCOMPLETE:
6016 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
6017 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Selection Timeout @ %s:%d", __func__, __LINE__);
6019 XS_SETERR(xs, HBA_SELTIMEOUT);
6020 *rp = XS_XFRLEN(xs);
6024 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Incomplete, state 0x%x", sp->req_state_flags);
6027 case RQCS_DMA_ERROR:
6028 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA Error");
6029 *rp = XS_XFRLEN(xs);
6032 case RQCS_TRANSPORT_ERROR:
6035 ISP_SNPRINTF(buf, sizeof (buf), "states=>");
6036 if (sp->req_state_flags & RQSF_GOT_BUS) {
6037 ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_BUS", buf);
6039 if (sp->req_state_flags & RQSF_GOT_TARGET) {
6040 ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_TGT", buf);
6042 if (sp->req_state_flags & RQSF_SENT_CDB) {
6043 ISP_SNPRINTF(buf, sizeof (buf), "%s SENT_CDB", buf);
6045 if (sp->req_state_flags & RQSF_XFRD_DATA) {
6046 ISP_SNPRINTF(buf, sizeof (buf), "%s XFRD_DATA", buf);
6048 if (sp->req_state_flags & RQSF_GOT_STATUS) {
6049 ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_STS", buf);
6051 if (sp->req_state_flags & RQSF_GOT_SENSE) {
6052 ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_SNS", buf);
6054 if (sp->req_state_flags & RQSF_XFER_COMPLETE) {
6055 ISP_SNPRINTF(buf, sizeof (buf), "%s XFR_CMPLT", buf);
6057 ISP_SNPRINTF(buf, sizeof (buf), "%s\nstatus=>", buf);
6058 if (sp->req_status_flags & RQSTF_DISCONNECT) {
6059 ISP_SNPRINTF(buf, sizeof (buf), "%s Disconnect", buf);
6061 if (sp->req_status_flags & RQSTF_SYNCHRONOUS) {
6062 ISP_SNPRINTF(buf, sizeof (buf), "%s Sync_xfr", buf);
6064 if (sp->req_status_flags & RQSTF_PARITY_ERROR) {
6065 ISP_SNPRINTF(buf, sizeof (buf), "%s Parity", buf);
6067 if (sp->req_status_flags & RQSTF_BUS_RESET) {
6068 ISP_SNPRINTF(buf, sizeof (buf), "%s Bus_Reset", buf);
6070 if (sp->req_status_flags & RQSTF_DEVICE_RESET) {
6071 ISP_SNPRINTF(buf, sizeof (buf), "%s Device_Reset", buf);
6073 if (sp->req_status_flags & RQSTF_ABORTED) {
6074 ISP_SNPRINTF(buf, sizeof (buf), "%s Aborted", buf);
6076 if (sp->req_status_flags & RQSTF_TIMEOUT) {
6077 ISP_SNPRINTF(buf, sizeof (buf), "%s Timeout", buf);
6079 if (sp->req_status_flags & RQSTF_NEGOTIATION) {
6080 ISP_SNPRINTF(buf, sizeof (buf), "%s Negotiation", buf);
6082 isp_xs_prt(isp, xs, ISP_LOGERR, "Transport Error: %s", buf);
6083 *rp = XS_XFRLEN(xs);
6086 case RQCS_RESET_OCCURRED:
6089 isp_xs_prt(isp, xs, ISP_LOGWARN, "Bus Reset destroyed command");
6090 for (chan = 0; chan < isp->isp_nchan; chan++) {
6091 FCPARAM(isp, chan)->sendmarker = 1;
6094 XS_SETERR(xs, HBA_BUSRESET);
6096 *rp = XS_XFRLEN(xs);
6100 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
6101 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
6103 XS_SETERR(xs, HBA_ABORTED);
6108 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command timed out");
6110 * XXX: Check to see if we logged out of the device.
6113 XS_SETERR(xs, HBA_CMDTIMEOUT);
6117 case RQCS_DATA_OVERRUN:
6118 XS_SET_RESID(xs, sp->req_resid);
6119 isp_xs_prt(isp, xs, ISP_LOGERR, "data overrun (%ld)", (long) XS_GET_RESID(xs));
6121 XS_SETERR(xs, HBA_DATAOVR);
6125 case RQCS_COMMAND_OVERRUN:
6126 isp_xs_prt(isp, xs, ISP_LOGERR, "command overrun");
6129 case RQCS_STATUS_OVERRUN:
6130 isp_xs_prt(isp, xs, ISP_LOGERR, "status overrun");
6133 case RQCS_BAD_MESSAGE:
6134 isp_xs_prt(isp, xs, ISP_LOGERR, "msg not COMMAND COMPLETE after status");
6137 case RQCS_NO_MESSAGE_OUT:
6138 isp_xs_prt(isp, xs, ISP_LOGERR, "No MESSAGE OUT phase after selection");
6141 case RQCS_EXT_ID_FAILED:
6142 isp_xs_prt(isp, xs, ISP_LOGERR, "EXTENDED IDENTIFY failed");
6145 case RQCS_IDE_MSG_FAILED:
6146 isp_xs_prt(isp, xs, ISP_LOGERR, "INITIATOR DETECTED ERROR rejected");
6149 case RQCS_ABORT_MSG_FAILED:
6150 isp_xs_prt(isp, xs, ISP_LOGERR, "ABORT OPERATION rejected");
6153 case RQCS_REJECT_MSG_FAILED:
6154 isp_xs_prt(isp, xs, ISP_LOGERR, "MESSAGE REJECT rejected");
6157 case RQCS_NOP_MSG_FAILED:
6158 isp_xs_prt(isp, xs, ISP_LOGERR, "NOP rejected");
6161 case RQCS_PARITY_ERROR_MSG_FAILED:
6162 isp_xs_prt(isp, xs, ISP_LOGERR, "MESSAGE PARITY ERROR rejected");
6165 case RQCS_DEVICE_RESET_MSG_FAILED:
6166 isp_xs_prt(isp, xs, ISP_LOGWARN, "BUS DEVICE RESET rejected");
6169 case RQCS_ID_MSG_FAILED:
6170 isp_xs_prt(isp, xs, ISP_LOGERR, "IDENTIFY rejected");
6173 case RQCS_UNEXP_BUS_FREE:
6174 isp_xs_prt(isp, xs, ISP_LOGERR, "Unexpected Bus Free");
6177 case RQCS_DATA_UNDERRUN:
6180 int ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
6181 if (!ru_marked || sp->req_resid > XS_XFRLEN(xs)) {
6182 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6184 XS_SETERR(xs, HBA_BOTCH);
6189 XS_SET_RESID(xs, sp->req_resid);
6191 XS_SETERR(xs, HBA_NOERROR);
6196 case RQCS_XACT_ERR1:
6197 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued transaction with disconnect not set");
6200 case RQCS_XACT_ERR2:
6201 isp_xs_prt(isp, xs, ISP_LOGERR,
6202 "HBA attempted queued transaction to target routine %jx",
6203 (uintmax_t)XS_LUN(xs));
6206 case RQCS_XACT_ERR3:
6207 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued cmd when queueing disabled");
6210 case RQCS_BAD_ENTRY:
6211 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
6214 case RQCS_QUEUE_FULL:
6215 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "internal queues full status 0x%x", *XS_STSP(xs));
6218 * If QFULL or some other status byte is set, then this
6219 * isn't an error, per se.
6221 * Unfortunately, some QLogic f/w writers have, in
6222 * some cases, omitted to *set* status to QFULL.
6225 if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
6226 XS_SETERR(xs, HBA_NOERROR);
6231 *XS_STSP(xs) = SCSI_QFULL;
6232 XS_SETERR(xs, HBA_NOERROR);
6235 case RQCS_PHASE_SKIPPED:
6236 isp_xs_prt(isp, xs, ISP_LOGERR, "SCSI phase skipped");
6239 case RQCS_ARQS_FAILED:
6240 isp_xs_prt(isp, xs, ISP_LOGERR, "Auto Request Sense Failed");
6242 XS_SETERR(xs, HBA_ARQFAIL);
6246 case RQCS_WIDE_FAILED:
6247 isp_xs_prt(isp, xs, ISP_LOGERR, "Wide Negotiation Failed");
6249 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
6250 sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_WIDE;
6251 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
6255 XS_SETERR(xs, HBA_NOERROR);
6259 case RQCS_SYNCXFER_FAILED:
6260 isp_xs_prt(isp, xs, ISP_LOGERR, "SDTR Message Failed");
6262 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
6263 sdp += XS_CHANNEL(xs);
6264 sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_SYNC;
6265 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
6270 case RQCS_LVD_BUSERR:
6271 isp_xs_prt(isp, xs, ISP_LOGERR, "Bad LVD condition");
6274 case RQCS_PORT_UNAVAILABLE:
6276 * No such port on the loop. Moral equivalent of SELTIMEO
6278 case RQCS_PORT_LOGGED_OUT:
6281 uint8_t sts = sp->req_completion_status & 0xff;
6282 fcparam *fcp = FCPARAM(isp, 0);
6286 * It was there (maybe)- treat as a selection timeout.
6288 if (sts == RQCS_PORT_UNAVAILABLE) {
6289 reason = "unavailable";
6294 isp_prt(isp, ISP_LOGINFO, "port %s for target %d", reason, XS_TGT(xs));
6296 /* XXX: Should we trigger rescan or FW announce change? */
6299 lp = &fcp->portdb[XS_TGT(xs)];
6300 if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
6301 *XS_STSP(xs) = SCSI_BUSY;
6302 XS_SETERR(xs, HBA_TGTBSY);
6304 XS_SETERR(xs, HBA_SELTIMEOUT);
6308 case RQCS_PORT_CHANGED:
6309 isp_prt(isp, ISP_LOGWARN, "port changed for target %d", XS_TGT(xs));
6311 *XS_STSP(xs) = SCSI_BUSY;
6312 XS_SETERR(xs, HBA_TGTBSY);
6316 case RQCS_PORT_BUSY:
6317 isp_prt(isp, ISP_LOGWARN, "port busy for target %d", XS_TGT(xs));
6319 *XS_STSP(xs) = SCSI_BUSY;
6320 XS_SETERR(xs, HBA_TGTBSY);
6325 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x", sp->req_completion_status);
6329 XS_SETERR(xs, HBA_BOTCH);
6334 isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp, XS_T *xs, uint32_t *rp)
6336 int ru_marked, sv_marked;
6337 int chan = XS_CHANNEL(xs);
6339 switch (sp->req_completion_status) {
6342 XS_SETERR(xs, HBA_NOERROR);
6346 case RQCS_DMA_ERROR:
6347 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA error");
6350 case RQCS_TRANSPORT_ERROR:
6351 isp_xs_prt(isp, xs, ISP_LOGERR, "Transport Error");
6354 case RQCS_RESET_OCCURRED:
6355 isp_xs_prt(isp, xs, ISP_LOGWARN, "reset destroyed command");
6356 FCPARAM(isp, chan)->sendmarker = 1;
6358 XS_SETERR(xs, HBA_BUSRESET);
6363 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
6364 FCPARAM(isp, chan)->sendmarker = 1;
6366 XS_SETERR(xs, HBA_ABORTED);
6371 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command Timed Out");
6373 XS_SETERR(xs, HBA_CMDTIMEOUT);
6377 case RQCS_DATA_OVERRUN:
6378 XS_SET_RESID(xs, sp->req_resid);
6379 isp_xs_prt(isp, xs, ISP_LOGERR, "Data Overrun");
6381 XS_SETERR(xs, HBA_DATAOVR);
6385 case RQCS_24XX_DRE: /* data reassembly error */
6386 isp_prt(isp, ISP_LOGERR, "Chan %d data reassembly error for target %d", chan, XS_TGT(xs));
6388 XS_SETERR(xs, HBA_ABORTED);
6390 *rp = XS_XFRLEN(xs);
6393 case RQCS_24XX_TABORT: /* aborted by target */
6394 isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS", chan, XS_TGT(xs));
6396 XS_SETERR(xs, HBA_ABORTED);
6400 case RQCS_DATA_UNDERRUN:
6401 ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
6403 * We can get an underrun w/o things being marked
6404 * if we got a non-zero status.
6406 sv_marked = (sp->req_scsi_status & (RQCS_SV|RQCS_RV)) != 0;
6407 if ((ru_marked == 0 && sv_marked == 0) ||
6408 (sp->req_resid > XS_XFRLEN(xs))) {
6409 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6411 XS_SETERR(xs, HBA_BOTCH);
6415 XS_SET_RESID(xs, sp->req_resid);
6416 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
6418 XS_SETERR(xs, HBA_NOERROR);
6422 case RQCS_PORT_UNAVAILABLE:
6424 * No such port on the loop. Moral equivalent of SELTIMEO
6426 case RQCS_PORT_LOGGED_OUT:
6429 uint8_t sts = sp->req_completion_status & 0xff;
6430 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
6434 * It was there (maybe)- treat as a selection timeout.
6436 if (sts == RQCS_PORT_UNAVAILABLE) {
6437 reason = "unavailable";
6442 isp_prt(isp, ISP_LOGINFO, "Chan %d port %s for target %d",
6443 chan, reason, XS_TGT(xs));
6445 /* XXX: Should we trigger rescan or FW announce change? */
6448 lp = &fcp->portdb[XS_TGT(xs)];
6449 if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
6450 *XS_STSP(xs) = SCSI_BUSY;
6451 XS_SETERR(xs, HBA_TGTBSY);
6453 XS_SETERR(xs, HBA_SELTIMEOUT);
6457 case RQCS_PORT_CHANGED:
6458 isp_prt(isp, ISP_LOGWARN, "port changed for target %d chan %d", XS_TGT(xs), chan);
6460 *XS_STSP(xs) = SCSI_BUSY;
6461 XS_SETERR(xs, HBA_TGTBSY);
6465 case RQCS_24XX_ENOMEM: /* f/w resource unavailable */
6466 isp_prt(isp, ISP_LOGWARN, "f/w resource unavailable for target %d chan %d", XS_TGT(xs), chan);
6468 *XS_STSP(xs) = SCSI_BUSY;
6469 XS_SETERR(xs, HBA_TGTBSY);
6473 case RQCS_24XX_TMO: /* task management overrun */
6474 isp_prt(isp, ISP_LOGWARN, "command for target %d overlapped task management for chan %d", XS_TGT(xs), chan);
6476 *XS_STSP(xs) = SCSI_BUSY;
6477 XS_SETERR(xs, HBA_TGTBSY);
6482 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x on chan %d", sp->req_completion_status, chan);
6486 XS_SETERR(xs, HBA_BOTCH);
6491 isp_fastpost_complete(ispsoftc_t *isp, uint32_t fph)
6498 xs = isp_find_xs(isp, fph);
6500 isp_prt(isp, ISP_LOGWARN,
6501 "Command for fast post handle 0x%x not found", fph);
6504 isp_destroy_handle(isp, fph);
6507 * Since we don't have a result queue entry item,
6508 * we must believe that SCSI status is zero and
6509 * that all data transferred.
6511 XS_SET_RESID(xs, 0);
6512 *XS_STSP(xs) = SCSI_GOOD;
6513 if (XS_XFRLEN(xs)) {
6514 ISP_DMAFREE(isp, xs, fph);
6519 #define ISP_SCSI_IBITS(op) (mbpscsi[((op)<<1)])
6520 #define ISP_SCSI_OBITS(op) (mbpscsi[((op)<<1) + 1])
6521 #define ISP_SCSI_OPMAP(in, out) in, out
6522 static const uint8_t mbpscsi[] = {
6523 ISP_SCSI_OPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
6524 ISP_SCSI_OPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
6525 ISP_SCSI_OPMAP(0x03, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */
6526 ISP_SCSI_OPMAP(0x1f, 0x01), /* 0x03: MBOX_DUMP_RAM */
6527 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
6528 ISP_SCSI_OPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
6529 ISP_SCSI_OPMAP(0x3f, 0x3f), /* 0x06: MBOX_MAILBOX_REG_TEST */
6530 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */
6531 ISP_SCSI_OPMAP(0x01, 0x0f), /* 0x08: MBOX_ABOUT_FIRMWARE */
6532 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x09: */
6533 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x0a: */
6534 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x0b: */
6535 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x0c: */
6536 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x0d: */
6537 ISP_SCSI_OPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
6538 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x0f: */
6539 ISP_SCSI_OPMAP(0x1f, 0x1f), /* 0x10: MBOX_INIT_REQ_QUEUE */
6540 ISP_SCSI_OPMAP(0x3f, 0x3f), /* 0x11: MBOX_INIT_RES_QUEUE */
6541 ISP_SCSI_OPMAP(0x0f, 0x0f), /* 0x12: MBOX_EXECUTE_IOCB */
6542 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */
6543 ISP_SCSI_OPMAP(0x01, 0x3f), /* 0x14: MBOX_STOP_FIRMWARE */
6544 ISP_SCSI_OPMAP(0x0f, 0x0f), /* 0x15: MBOX_ABORT */
6545 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x16: MBOX_ABORT_DEVICE */
6546 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x17: MBOX_ABORT_TARGET */
6547 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x18: MBOX_BUS_RESET */
6548 ISP_SCSI_OPMAP(0x03, 0x07), /* 0x19: MBOX_STOP_QUEUE */
6549 ISP_SCSI_OPMAP(0x03, 0x07), /* 0x1a: MBOX_START_QUEUE */
6550 ISP_SCSI_OPMAP(0x03, 0x07), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6551 ISP_SCSI_OPMAP(0x03, 0x07), /* 0x1c: MBOX_ABORT_QUEUE */
6552 ISP_SCSI_OPMAP(0x03, 0x4f), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6553 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x1e: */
6554 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6555 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x20: MBOX_GET_INIT_SCSI_ID */
6556 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x21: MBOX_GET_SELECT_TIMEOUT */
6557 ISP_SCSI_OPMAP(0x01, 0xc7), /* 0x22: MBOX_GET_RETRY_COUNT */
6558 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
6559 ISP_SCSI_OPMAP(0x01, 0x03), /* 0x24: MBOX_GET_CLOCK_RATE */
6560 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x25: MBOX_GET_ACT_NEG_STATE */
6561 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
6562 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x27: MBOX_GET_PCI_PARAMS */
6563 ISP_SCSI_OPMAP(0x03, 0x4f), /* 0x28: MBOX_GET_TARGET_PARAMS */
6564 ISP_SCSI_OPMAP(0x03, 0x0f), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
6565 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */
6566 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x2b: */
6567 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x2c: */
6568 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x2d: */
6569 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x2e: */
6570 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x2f: */
6571 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x30: MBOX_SET_INIT_SCSI_ID */
6572 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x31: MBOX_SET_SELECT_TIMEOUT */
6573 ISP_SCSI_OPMAP(0xc7, 0xc7), /* 0x32: MBOX_SET_RETRY_COUNT */
6574 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
6575 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x34: MBOX_SET_CLOCK_RATE */
6576 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x35: MBOX_SET_ACT_NEG_STATE */
6577 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
6578 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
6579 ISP_SCSI_OPMAP(0x4f, 0x4f), /* 0x38: MBOX_SET_TARGET_PARAMS */
6580 ISP_SCSI_OPMAP(0x0f, 0x0f), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
6581 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */
6582 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x3b: */
6583 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x3c: */
6584 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x3d: */
6585 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x3e: */
6586 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x3f: */
6587 ISP_SCSI_OPMAP(0x01, 0x03), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
6588 ISP_SCSI_OPMAP(0x3f, 0x01), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
6589 ISP_SCSI_OPMAP(0x03, 0x07), /* 0x42: MBOX_EXEC_BIOS_IOCB */
6590 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x43: */
6591 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x44: */
6592 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x45: SET SYSTEM PARAMETER */
6593 ISP_SCSI_OPMAP(0x01, 0x03), /* 0x46: GET SYSTEM PARAMETER */
6594 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x47: */
6595 ISP_SCSI_OPMAP(0x01, 0xcf), /* 0x48: GET SCAM CONFIGURATION */
6596 ISP_SCSI_OPMAP(0xcf, 0xcf), /* 0x49: SET SCAM CONFIGURATION */
6597 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x4a: MBOX_SET_FIRMWARE_FEATURES */
6598 ISP_SCSI_OPMAP(0x01, 0x03), /* 0x4b: MBOX_GET_FIRMWARE_FEATURES */
6599 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x4c: */
6600 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x4d: */
6601 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x4e: */
6602 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x4f: */
6603 ISP_SCSI_OPMAP(0xdf, 0xdf), /* 0x50: LOAD RAM A64 */
6604 ISP_SCSI_OPMAP(0xdf, 0xdf), /* 0x51: DUMP RAM A64 */
6605 ISP_SCSI_OPMAP(0xdf, 0xff), /* 0x52: INITIALIZE REQUEST QUEUE A64 */
6606 ISP_SCSI_OPMAP(0xef, 0xff), /* 0x53: INITIALIZE RESPONSE QUEUE A64 */
6607 ISP_SCSI_OPMAP(0xcf, 0x01), /* 0x54: EXECUCUTE COMMAND IOCB A64 */
6608 ISP_SCSI_OPMAP(0x07, 0x01), /* 0x55: ENABLE TARGET MODE */
6609 ISP_SCSI_OPMAP(0x03, 0x0f), /* 0x56: GET TARGET STATUS */
6610 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x57: */
6611 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x58: */
6612 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x59: */
6613 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x5a: SET DATA OVERRUN RECOVERY MODE */
6614 ISP_SCSI_OPMAP(0x01, 0x03), /* 0x5b: GET DATA OVERRUN RECOVERY MODE */
6615 ISP_SCSI_OPMAP(0x0f, 0x0f), /* 0x5c: SET HOST DATA */
6616 ISP_SCSI_OPMAP(0x01, 0x01) /* 0x5d: GET NOST DATA */
6618 #define MAX_SCSI_OPCODE 0x5d
6620 static const char *scsi_mbcmd_names[] = {
6637 "INIT REQUEST QUEUE",
6638 "INIT RESULT QUEUE",
6648 "SINGLE STEP QUEUE",
6650 "GET DEV QUEUE STATUS",
6652 "GET FIRMWARE STATUS",
6654 "GET SELECT TIMEOUT",
6656 "GET TAG AGE LIMIT",
6658 "GET ACT NEG STATE",
6659 "GET ASYNC DATA SETUP TIME",
6661 "GET TARGET PARAMS",
6662 "GET DEV QUEUE PARAMS",
6663 "GET RESET DELAY PARAMS",
6670 "SET SELECT TIMEOUT",
6672 "SET TAG AGE LIMIT",
6674 "SET ACT NEG STATE",
6675 "SET ASYNC DATA SETUP TIME",
6676 "SET PCI CONTROL PARAMS",
6677 "SET TARGET PARAMS",
6678 "SET DEV QUEUE PARAMS",
6679 "SET RESET DELAY PARAMS",
6685 "RETURN BIOS BLOCK ADDR",
6686 "WRITE FOUR RAM WORDS",
6690 "SET SYSTEM PARAMETER",
6691 "GET SYSTEM PARAMETER",
6693 "GET SCAM CONFIGURATION",
6694 "SET SCAM CONFIGURATION",
6695 "SET FIRMWARE FEATURES",
6696 "GET FIRMWARE FEATURES",
6703 "INITIALIZE REQUEST QUEUE A64",
6704 "INITIALIZE RESPONSE QUEUE A64",
6706 "ENABLE TARGET MODE",
6707 "GET TARGET MODE STATE",
6711 "SET DATA OVERRUN RECOVERY MODE",
6712 "GET DATA OVERRUN RECOVERY MODE",
6717 #define ISP_FC_IBITS(op) ((mbpfc[((op)<<3) + 0] << 24) | (mbpfc[((op)<<3) + 1] << 16) | (mbpfc[((op)<<3) + 2] << 8) | (mbpfc[((op)<<3) + 3]))
6718 #define ISP_FC_OBITS(op) ((mbpfc[((op)<<3) + 4] << 24) | (mbpfc[((op)<<3) + 5] << 16) | (mbpfc[((op)<<3) + 6] << 8) | (mbpfc[((op)<<3) + 7]))
6720 #define ISP_FC_OPMAP(in0, out0) 0, 0, 0, in0, 0, 0, 0, out0
6721 #define ISP_FC_OPMAP_HALF(in1, in0, out1, out0) 0, 0, in1, in0, 0, 0, out1, out0
6722 #define ISP_FC_OPMAP_FULL(in3, in2, in1, in0, out3, out2, out1, out0) in3, in2, in1, in0, out3, out2, out1, out0
6723 static const uint32_t mbpfc[] = {
6724 ISP_FC_OPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
6725 ISP_FC_OPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
6726 ISP_FC_OPMAP_HALF(0x07, 0xff, 0x00, 0x03), /* 0x02: MBOX_EXEC_FIRMWARE */
6727 ISP_FC_OPMAP(0xdf, 0x01), /* 0x03: MBOX_DUMP_RAM */
6728 ISP_FC_OPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
6729 ISP_FC_OPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
6730 ISP_FC_OPMAP_FULL(0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff), /* 0x06: MBOX_MAILBOX_REG_TEST */
6731 ISP_FC_OPMAP(0x07, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */
6732 ISP_FC_OPMAP_FULL(0x0, 0x0, 0x0, 0x01, 0x0, 0x3, 0x80, 0x7f), /* 0x08: MBOX_ABOUT_FIRMWARE */
6733 ISP_FC_OPMAP(0xdf, 0x01), /* 0x09: MBOX_LOAD_RISC_RAM_2100 */
6734 ISP_FC_OPMAP(0xdf, 0x01), /* 0x0a: DUMP RAM */
6735 ISP_FC_OPMAP_HALF(0x1, 0xff, 0x0, 0x01), /* 0x0b: MBOX_LOAD_RISC_RAM */
6736 ISP_FC_OPMAP(0x00, 0x00), /* 0x0c: */
6737 ISP_FC_OPMAP_HALF(0x1, 0x0f, 0x0, 0x01), /* 0x0d: MBOX_WRITE_RAM_WORD_EXTENDED */
6738 ISP_FC_OPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
6739 ISP_FC_OPMAP_HALF(0x1, 0x03, 0x0, 0x0d), /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED */
6740 ISP_FC_OPMAP(0x1f, 0x11), /* 0x10: MBOX_INIT_REQ_QUEUE */
6741 ISP_FC_OPMAP(0x2f, 0x21), /* 0x11: MBOX_INIT_RES_QUEUE */
6742 ISP_FC_OPMAP(0x0f, 0x01), /* 0x12: MBOX_EXECUTE_IOCB */
6743 ISP_FC_OPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */
6744 ISP_FC_OPMAP_HALF(0x1, 0xff, 0x0, 0x03), /* 0x14: MBOX_STOP_FIRMWARE */
6745 ISP_FC_OPMAP(0x4f, 0x01), /* 0x15: MBOX_ABORT */
6746 ISP_FC_OPMAP(0x07, 0x01), /* 0x16: MBOX_ABORT_DEVICE */
6747 ISP_FC_OPMAP(0x07, 0x01), /* 0x17: MBOX_ABORT_TARGET */
6748 ISP_FC_OPMAP(0x03, 0x03), /* 0x18: MBOX_BUS_RESET */
6749 ISP_FC_OPMAP(0x07, 0x05), /* 0x19: MBOX_STOP_QUEUE */
6750 ISP_FC_OPMAP(0x07, 0x05), /* 0x1a: MBOX_START_QUEUE */
6751 ISP_FC_OPMAP(0x07, 0x05), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6752 ISP_FC_OPMAP(0x07, 0x05), /* 0x1c: MBOX_ABORT_QUEUE */
6753 ISP_FC_OPMAP(0x07, 0x03), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6754 ISP_FC_OPMAP(0x00, 0x00), /* 0x1e: */
6755 ISP_FC_OPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6756 ISP_FC_OPMAP_HALF(0x2, 0x01, 0x7e, 0xcf), /* 0x20: MBOX_GET_LOOP_ID */
6757 ISP_FC_OPMAP(0x00, 0x00), /* 0x21: */
6758 ISP_FC_OPMAP(0x03, 0x4b), /* 0x22: MBOX_GET_TIMEOUT_PARAMS */
6759 ISP_FC_OPMAP(0x00, 0x00), /* 0x23: */
6760 ISP_FC_OPMAP(0x00, 0x00), /* 0x24: */
6761 ISP_FC_OPMAP(0x00, 0x00), /* 0x25: */
6762 ISP_FC_OPMAP(0x00, 0x00), /* 0x26: */
6763 ISP_FC_OPMAP(0x00, 0x00), /* 0x27: */
6764 ISP_FC_OPMAP(0x01, 0x03), /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */
6765 ISP_FC_OPMAP(0x03, 0x07), /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */
6766 ISP_FC_OPMAP(0x00, 0x00), /* 0x2a: */
6767 ISP_FC_OPMAP(0x00, 0x00), /* 0x2b: */
6768 ISP_FC_OPMAP(0x00, 0x00), /* 0x2c: */
6769 ISP_FC_OPMAP(0x00, 0x00), /* 0x2d: */
6770 ISP_FC_OPMAP(0x00, 0x00), /* 0x2e: */
6771 ISP_FC_OPMAP(0x00, 0x00), /* 0x2f: */
6772 ISP_FC_OPMAP(0x00, 0x00), /* 0x30: */
6773 ISP_FC_OPMAP(0x00, 0x00), /* 0x31: */
6774 ISP_FC_OPMAP(0x4b, 0x4b), /* 0x32: MBOX_SET_TIMEOUT_PARAMS */
6775 ISP_FC_OPMAP(0x00, 0x00), /* 0x33: */
6776 ISP_FC_OPMAP(0x00, 0x00), /* 0x34: */
6777 ISP_FC_OPMAP(0x00, 0x00), /* 0x35: */
6778 ISP_FC_OPMAP(0x00, 0x00), /* 0x36: */
6779 ISP_FC_OPMAP(0x00, 0x00), /* 0x37: */
6780 ISP_FC_OPMAP(0x0f, 0x01), /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */
6781 ISP_FC_OPMAP(0x0f, 0x07), /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */
6782 ISP_FC_OPMAP(0x00, 0x00), /* 0x3a: */
6783 ISP_FC_OPMAP(0x00, 0x00), /* 0x3b: */
6784 ISP_FC_OPMAP(0x00, 0x00), /* 0x3c: */
6785 ISP_FC_OPMAP(0x00, 0x00), /* 0x3d: */
6786 ISP_FC_OPMAP(0x00, 0x00), /* 0x3e: */
6787 ISP_FC_OPMAP(0x00, 0x00), /* 0x3f: */
6788 ISP_FC_OPMAP(0x03, 0x01), /* 0x40: MBOX_LOOP_PORT_BYPASS */
6789 ISP_FC_OPMAP(0x03, 0x01), /* 0x41: MBOX_LOOP_PORT_ENABLE */
6790 ISP_FC_OPMAP_HALF(0x0, 0x01, 0x1f, 0xcf), /* 0x42: MBOX_GET_RESOURCE_COUNT */
6791 ISP_FC_OPMAP(0x01, 0x01), /* 0x43: MBOX_REQUEST_OFFLINE_MODE */
6792 ISP_FC_OPMAP(0x00, 0x00), /* 0x44: */
6793 ISP_FC_OPMAP(0x00, 0x00), /* 0x45: */
6794 ISP_FC_OPMAP(0x00, 0x00), /* 0x46: */
6795 ISP_FC_OPMAP(0xcf, 0x03), /* 0x47: GET PORT_DATABASE ENHANCED */
6796 ISP_FC_OPMAP(0xcf, 0x0f), /* 0x48: MBOX_INIT_FIRMWARE_MULTI_ID */
6797 ISP_FC_OPMAP(0xcd, 0x01), /* 0x49: MBOX_GET_VP_DATABASE */
6798 ISP_FC_OPMAP_HALF(0x2, 0xcd, 0x0, 0x01), /* 0x4a: MBOX_GET_VP_DATABASE_ENTRY */
6799 ISP_FC_OPMAP(0x00, 0x00), /* 0x4b: */
6800 ISP_FC_OPMAP(0x00, 0x00), /* 0x4c: */
6801 ISP_FC_OPMAP(0x00, 0x00), /* 0x4d: */
6802 ISP_FC_OPMAP(0x00, 0x00), /* 0x4e: */
6803 ISP_FC_OPMAP(0x00, 0x00), /* 0x4f: */
6804 ISP_FC_OPMAP(0x00, 0x00), /* 0x50: */
6805 ISP_FC_OPMAP(0x00, 0x00), /* 0x51: */
6806 ISP_FC_OPMAP(0x00, 0x00), /* 0x52: */
6807 ISP_FC_OPMAP(0x00, 0x00), /* 0x53: */
6808 ISP_FC_OPMAP(0xcf, 0x01), /* 0x54: EXECUTE IOCB A64 */
6809 ISP_FC_OPMAP(0x00, 0x00), /* 0x55: */
6810 ISP_FC_OPMAP(0x00, 0x00), /* 0x56: */
6811 ISP_FC_OPMAP(0x00, 0x00), /* 0x57: */
6812 ISP_FC_OPMAP(0x00, 0x00), /* 0x58: */
6813 ISP_FC_OPMAP(0x00, 0x00), /* 0x59: */
6814 ISP_FC_OPMAP(0x00, 0x00), /* 0x5a: */
6815 ISP_FC_OPMAP(0x03, 0x01), /* 0x5b: MBOX_DRIVER_HEARTBEAT */
6816 ISP_FC_OPMAP(0xcf, 0x01), /* 0x5c: MBOX_FW_HEARTBEAT */
6817 ISP_FC_OPMAP(0x07, 0x1f), /* 0x5d: MBOX_GET_SET_DATA_RATE */
6818 ISP_FC_OPMAP(0x00, 0x00), /* 0x5e: */
6819 ISP_FC_OPMAP(0x00, 0x00), /* 0x5f: */
6820 ISP_FC_OPMAP(0xcf, 0x0f), /* 0x60: MBOX_INIT_FIRMWARE */
6821 ISP_FC_OPMAP(0x00, 0x00), /* 0x61: */
6822 ISP_FC_OPMAP(0x01, 0x01), /* 0x62: MBOX_INIT_LIP */
6823 ISP_FC_OPMAP(0xcd, 0x03), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
6824 ISP_FC_OPMAP(0xcf, 0x01), /* 0x64: MBOX_GET_PORT_DB */
6825 ISP_FC_OPMAP(0x07, 0x01), /* 0x65: MBOX_CLEAR_ACA */
6826 ISP_FC_OPMAP(0x07, 0x01), /* 0x66: MBOX_TARGET_RESET */
6827 ISP_FC_OPMAP(0x07, 0x01), /* 0x67: MBOX_CLEAR_TASK_SET */
6828 ISP_FC_OPMAP(0x07, 0x01), /* 0x68: MBOX_ABORT_TASK_SET */
6829 ISP_FC_OPMAP(0x01, 0x07), /* 0x69: MBOX_GET_FW_STATE */
6830 ISP_FC_OPMAP_HALF(0x6, 0x03, 0x0, 0xcf), /* 0x6a: MBOX_GET_PORT_NAME */
6831 ISP_FC_OPMAP(0xcf, 0x01), /* 0x6b: MBOX_GET_LINK_STATUS */
6832 ISP_FC_OPMAP(0x0f, 0x01), /* 0x6c: MBOX_INIT_LIP_RESET */
6833 ISP_FC_OPMAP(0x00, 0x00), /* 0x6d: */
6834 ISP_FC_OPMAP(0xcf, 0x03), /* 0x6e: MBOX_SEND_SNS */
6835 ISP_FC_OPMAP(0x0f, 0x07), /* 0x6f: MBOX_FABRIC_LOGIN */
6836 ISP_FC_OPMAP_HALF(0x02, 0x03, 0x00, 0x03), /* 0x70: MBOX_SEND_CHANGE_REQUEST */
6837 ISP_FC_OPMAP(0x03, 0x03), /* 0x71: MBOX_FABRIC_LOGOUT */
6838 ISP_FC_OPMAP(0x0f, 0x0f), /* 0x72: MBOX_INIT_LIP_LOGIN */
6839 ISP_FC_OPMAP(0x00, 0x00), /* 0x73: */
6840 ISP_FC_OPMAP(0x07, 0x01), /* 0x74: LOGIN LOOP PORT */
6841 ISP_FC_OPMAP_HALF(0x03, 0xcf, 0x00, 0x07), /* 0x75: GET PORT/NODE NAME LIST */
6842 ISP_FC_OPMAP(0x4f, 0x01), /* 0x76: SET VENDOR ID */
6843 ISP_FC_OPMAP(0xcd, 0x01), /* 0x77: INITIALIZE IP MAILBOX */
6844 ISP_FC_OPMAP(0x00, 0x00), /* 0x78: */
6845 ISP_FC_OPMAP(0x00, 0x00), /* 0x79: */
6846 ISP_FC_OPMAP(0x00, 0x00), /* 0x7a: */
6847 ISP_FC_OPMAP(0x00, 0x00), /* 0x7b: */
6848 ISP_FC_OPMAP_HALF(0x03, 0x4f, 0x00, 0x07), /* 0x7c: Get ID List */
6849 ISP_FC_OPMAP(0xcf, 0x01), /* 0x7d: SEND LFA */
6850 ISP_FC_OPMAP(0x0f, 0x01) /* 0x7e: LUN RESET */
6852 #define MAX_FC_OPCODE 0x7e
6856 * (1): this sets bits 21..16 in mailbox register #8, which we nominally
6857 * do not access at this time in the core driver. The caller is
6858 * responsible for setting this register first (Gross!). The assumption
6859 * is that we won't overflow.
6862 static const char *fc_mbcmd_names[] = {
6876 "WRITE RAM WORD EXTENDED",
6878 "READ RAM WORD EXTENDED",
6879 "INIT REQUEST QUEUE", /* 10h */
6880 "INIT RESULT QUEUE",
6890 "SINGLE STEP QUEUE",
6892 "GET DEV QUEUE STATUS",
6894 "GET FIRMWARE STATUS",
6895 "GET LOOP ID", /* 20h */
6897 "GET TIMEOUT PARAMS",
6903 "GET FIRMWARE OPTIONS",
6904 "GET PORT QUEUE PARAMS",
6905 "GENERATE SYSTEM ERROR",
6911 "WRITE SFP", /* 30h */
6913 "SET TIMEOUT PARAMS",
6919 "SET FIRMWARE OPTIONS",
6920 "SET PORT QUEUE PARAMS",
6924 "RESTART NIC FIRMWARE",
6927 "LOOP PORT BYPASS", /* 40h */
6929 "GET RESOURCE COUNT",
6930 "REQUEST NON PARTICIPATING MODE",
6931 "DIAGNOSTIC ECHO TEST",
6932 "DIAGNOSTIC LOOPBACK",
6934 "GET PORT DATABASE ENHANCED",
6935 "INIT FIRMWARE MULTI ID",
6937 "GET VP DATABASE ENTRY",
6943 "GET FCF LIST", /* 50h */
6944 "GET DCBX PARAMETERS",
6955 "FIRMWARE HEARTBEAT",
6956 "GET/SET DATA RATE",
6959 "INIT FIRMWARE", /* 60h */
6960 "GET INIT CONTROL BLOCK",
6962 "GET FC-AL POSITION MAP",
6963 "GET PORT DATABASE",
6972 "GET LINK STATS & PRIVATE DATA CNTS",
6975 "SEND CHANGE REQUEST", /* 70h */
6980 "GET PORT/NODE NAME LIST",
6982 "INITIALIZE IP MAILBOX",
6993 isp_mboxcmd(ispsoftc_t *isp, mbreg_t *mbp)
6995 const char *cname, *xname, *sname;
6996 char tname[16], mname[16];
6997 unsigned int ibits, obits, box, opcode;
6999 opcode = mbp->param[0];
7001 if (opcode > MAX_FC_OPCODE) {
7002 mbp->param[0] = MBOX_INVALID_COMMAND;
7003 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
7006 cname = fc_mbcmd_names[opcode];
7007 ibits = ISP_FC_IBITS(opcode);
7008 obits = ISP_FC_OBITS(opcode);
7010 if (opcode > MAX_SCSI_OPCODE) {
7011 mbp->param[0] = MBOX_INVALID_COMMAND;
7012 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
7015 cname = scsi_mbcmd_names[opcode];
7016 ibits = ISP_SCSI_IBITS(opcode);
7017 obits = ISP_SCSI_OBITS(opcode);
7019 if (cname == NULL) {
7021 ISP_SNPRINTF(tname, sizeof tname, "opcode %x", opcode);
7023 isp_prt(isp, ISP_LOGDEBUG3, "Mailbox Command '%s'", cname);
7026 * Pick up any additional bits that the caller might have set.
7028 ibits |= mbp->ibits;
7029 obits |= mbp->obits;
7032 * Mask any bits that the caller wants us to mask
7034 ibits &= mbp->ibitm;
7035 obits &= mbp->obitm;
7038 if (ibits == 0 && obits == 0) {
7039 mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
7040 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
7045 * Get exclusive usage of mailbox registers.
7047 if (MBOX_ACQUIRE(isp)) {
7048 mbp->param[0] = MBOX_REGS_BUSY;
7052 for (box = 0; box < ISP_NMBOX(isp); box++) {
7053 if (ibits & (1 << box)) {
7054 isp_prt(isp, ISP_LOGDEBUG3, "IN mbox %d = 0x%04x", box,
7056 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
7058 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
7061 isp->isp_lastmbxcmd = opcode;
7064 * We assume that we can't overwrite a previous command.
7066 isp->isp_obits = obits;
7067 isp->isp_mboxbsy = 1;
7070 * Set Host Interrupt condition so that RISC will pick up mailbox regs.
7073 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
7075 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
7079 * While we haven't finished the command, spin our wheels here.
7081 MBOX_WAIT_COMPLETE(isp, mbp);
7084 * Did the command time out?
7086 if (mbp->param[0] == MBOX_TIMEOUT) {
7087 isp->isp_mboxbsy = 0;
7093 * Copy back output registers.
7095 for (box = 0; box < ISP_NMBOX(isp); box++) {
7096 if (obits & (1 << box)) {
7097 mbp->param[box] = isp->isp_mboxtmp[box];
7098 isp_prt(isp, ISP_LOGDEBUG3, "OUT mbox %d = 0x%04x", box,
7103 isp->isp_mboxbsy = 0;
7106 if (mbp->logval == 0 || mbp->param[0] == MBOX_COMMAND_COMPLETE)
7109 if ((mbp->param[0] & 0xbfe0) == 0 &&
7110 (mbp->logval & MBLOGMASK(mbp->param[0])) == 0)
7115 switch (mbp->param[0]) {
7116 case MBOX_INVALID_COMMAND:
7117 xname = "INVALID COMMAND";
7119 case MBOX_HOST_INTERFACE_ERROR:
7120 xname = "HOST INTERFACE ERROR";
7122 case MBOX_TEST_FAILED:
7123 xname = "TEST FAILED";
7125 case MBOX_COMMAND_ERROR:
7126 xname = "COMMAND ERROR";
7127 ISP_SNPRINTF(mname, sizeof(mname), " subcode 0x%x",
7131 case MBOX_COMMAND_PARAM_ERROR:
7132 xname = "COMMAND PARAMETER ERROR";
7134 case MBOX_PORT_ID_USED:
7135 xname = "PORT ID ALREADY IN USE";
7137 case MBOX_LOOP_ID_USED:
7138 xname = "LOOP ID ALREADY IN USE";
7140 case MBOX_ALL_IDS_USED:
7141 xname = "ALL LOOP IDS IN USE";
7143 case MBOX_NOT_LOGGED_IN:
7144 xname = "NOT LOGGED IN";
7146 case MBOX_LINK_DOWN_ERROR:
7147 xname = "LINK DOWN ERROR";
7149 case MBOX_LOOPBACK_ERROR:
7150 xname = "LOOPBACK ERROR";
7152 case MBOX_CHECKSUM_ERROR:
7153 xname = "CHECKSUM ERROR";
7155 case MBOX_INVALID_PRODUCT_KEY:
7156 xname = "INVALID PRODUCT KEY";
7158 case MBOX_REGS_BUSY:
7159 xname = "REGISTERS BUSY";
7165 ISP_SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
7170 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s%s)",
7171 cname, xname, sname);
7176 isp_fw_state(ispsoftc_t *isp, int chan)
7181 MBSINIT(&mbs, MBOX_GET_FW_STATE, MBLOGALL, 0);
7182 isp_mboxcmd(isp, &mbs);
7183 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
7184 return (mbs.param[1]);
7191 isp_spi_update(ispsoftc_t *isp, int chan)
7199 * There are no 'per-bus' settings for Fibre Channel.
7203 sdp = SDPARAM(isp, chan);
7206 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7207 uint16_t flags, period, offset;
7210 if (sdp->isp_devparam[tgt].dev_enable == 0) {
7211 sdp->isp_devparam[tgt].dev_update = 0;
7212 sdp->isp_devparam[tgt].dev_refresh = 0;
7213 isp_prt(isp, ISP_LOGDEBUG0, "skipping target %d bus %d update", tgt, chan);
7217 * If the goal is to update the status of the device,
7218 * take what's in goal_flags and try and set the device
7219 * toward that. Otherwise, if we're just refreshing the
7220 * current device state, get the current parameters.
7223 MBSINIT(&mbs, 0, MBLOGALL, 0);
7226 * Refresh overrides set
7228 if (sdp->isp_devparam[tgt].dev_refresh) {
7229 mbs.param[0] = MBOX_GET_TARGET_PARAMS;
7231 } else if (sdp->isp_devparam[tgt].dev_update) {
7232 mbs.param[0] = MBOX_SET_TARGET_PARAMS;
7235 * Make sure goal_flags has "Renegotiate on Error"
7236 * on and "Freeze Queue on Error" off.
7238 sdp->isp_devparam[tgt].goal_flags |= DPARM_RENEG;
7239 sdp->isp_devparam[tgt].goal_flags &= ~DPARM_QFRZ;
7240 mbs.param[2] = sdp->isp_devparam[tgt].goal_flags;
7243 * Insist that PARITY must be enabled
7244 * if SYNC or WIDE is enabled.
7246 if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) {
7247 mbs.param[2] |= DPARM_PARITY;
7250 if (mbs.param[2] & DPARM_SYNC) {
7252 (sdp->isp_devparam[tgt].goal_offset << 8) |
7253 (sdp->isp_devparam[tgt].goal_period);
7256 * A command completion later that has
7257 * RQSTF_NEGOTIATION set can cause
7258 * the dev_refresh/announce cycle also.
7260 * Note: It is really important to update our current
7261 * flags with at least the state of TAG capabilities-
7262 * otherwise we might try and send a tagged command
7263 * when we have it all turned off. So change it here
7264 * to say that current already matches goal.
7266 sdp->isp_devparam[tgt].actv_flags &= ~DPARM_TQING;
7267 sdp->isp_devparam[tgt].actv_flags |=
7268 (sdp->isp_devparam[tgt].goal_flags & DPARM_TQING);
7269 isp_prt(isp, ISP_LOGDEBUG0, "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
7270 chan, tgt, mbs.param[2], mbs.param[3] >> 8, mbs.param[3] & 0xff);
7275 mbs.param[1] = (chan << 15) | (tgt << 8);
7276 isp_mboxcmd(isp, &mbs);
7277 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
7281 sdp->sendmarker = 1;
7282 sdp->isp_devparam[tgt].dev_update = 0;
7283 sdp->isp_devparam[tgt].dev_refresh = 1;
7285 sdp->isp_devparam[tgt].dev_refresh = 0;
7286 flags = mbs.param[2];
7287 period = mbs.param[3] & 0xff;
7288 offset = mbs.param[3] >> 8;
7289 sdp->isp_devparam[tgt].actv_flags = flags;
7290 sdp->isp_devparam[tgt].actv_period = period;
7291 sdp->isp_devparam[tgt].actv_offset = offset;
7292 isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, chan, tgt);
7296 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7297 if (sdp->isp_devparam[tgt].dev_update ||
7298 sdp->isp_devparam[tgt].dev_refresh) {
7306 isp_setdfltsdparm(ispsoftc_t *isp)
7309 sdparam *sdp, *sdp1;
7311 sdp = SDPARAM(isp, 0);
7312 if (IS_DUALBUS(isp))
7318 * Establish some default parameters.
7320 sdp->isp_cmd_dma_burst_enable = 0;
7321 sdp->isp_data_dma_burst_enabl = 1;
7322 sdp->isp_fifo_threshold = 0;
7323 sdp->isp_initiator_id = DEFAULT_IID(isp, 0);
7324 if (isp->isp_type >= ISP_HA_SCSI_1040) {
7325 sdp->isp_async_data_setup = 9;
7327 sdp->isp_async_data_setup = 6;
7329 sdp->isp_selection_timeout = 250;
7330 sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
7331 sdp->isp_tag_aging = 8;
7332 sdp->isp_bus_reset_delay = 5;
7334 * Don't retry selection, busy or queue full automatically- reflect
7337 sdp->isp_retry_count = 0;
7338 sdp->isp_retry_delay = 0;
7340 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7341 sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE;
7342 sdp->isp_devparam[tgt].dev_enable = 1;
7346 * The trick here is to establish a default for the default (honk!)
7347 * state (goal_flags). Then try and get the current status from
7348 * the card to fill in the current state. We don't, in fact, set
7349 * the default to the SAFE default state- that's not the goal state.
7351 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7353 sdp->isp_devparam[tgt].actv_offset = 0;
7354 sdp->isp_devparam[tgt].actv_period = 0;
7355 sdp->isp_devparam[tgt].actv_flags = 0;
7357 sdp->isp_devparam[tgt].goal_flags =
7358 sdp->isp_devparam[tgt].nvrm_flags = DPARM_DEFAULT;
7361 * We default to Wide/Fast for versions less than a 1040
7362 * (unless it's SBus).
7364 if (IS_ULTRA3(isp)) {
7365 off = ISP_80M_SYNCPARMS >> 8;
7366 per = ISP_80M_SYNCPARMS & 0xff;
7367 } else if (IS_ULTRA2(isp)) {
7368 off = ISP_40M_SYNCPARMS >> 8;
7369 per = ISP_40M_SYNCPARMS & 0xff;
7370 } else if (IS_1240(isp)) {
7371 off = ISP_20M_SYNCPARMS >> 8;
7372 per = ISP_20M_SYNCPARMS & 0xff;
7373 } else if ((isp->isp_bustype == ISP_BT_SBUS &&
7374 isp->isp_type < ISP_HA_SCSI_1020A) ||
7375 (isp->isp_bustype == ISP_BT_PCI &&
7376 isp->isp_type < ISP_HA_SCSI_1040) ||
7377 (isp->isp_clock && isp->isp_clock < 60) ||
7378 (sdp->isp_ultramode == 0)) {
7379 off = ISP_10M_SYNCPARMS >> 8;
7380 per = ISP_10M_SYNCPARMS & 0xff;
7382 off = ISP_20M_SYNCPARMS_1040 >> 8;
7383 per = ISP_20M_SYNCPARMS_1040 & 0xff;
7385 sdp->isp_devparam[tgt].goal_offset =
7386 sdp->isp_devparam[tgt].nvrm_offset = off;
7387 sdp->isp_devparam[tgt].goal_period =
7388 sdp->isp_devparam[tgt].nvrm_period = per;
7393 * If we're a dual bus card, just copy the data over
7397 sdp1->isp_initiator_id = DEFAULT_IID(isp, 1);
7401 * If we've not been told to avoid reading NVRAM, try and read it.
7402 * If we're successful reading it, we can then return because NVRAM
7403 * will tell us what the desired settings are. Otherwise, we establish
7404 * some reasonable 'fake' nvram and goal defaults.
7406 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7409 if (isp_read_nvram(isp, 0) == 0) {
7410 if (IS_DUALBUS(isp)) {
7411 if (isp_read_nvram(isp, 1) == 0) {
7416 MBSINIT(&mbs, MBOX_GET_ACT_NEG_STATE, MBLOGNONE, 0);
7417 isp_mboxcmd(isp, &mbs);
7418 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
7419 sdp->isp_req_ack_active_neg = 1;
7420 sdp->isp_data_line_active_neg = 1;
7422 sdp1->isp_req_ack_active_neg = 1;
7423 sdp1->isp_data_line_active_neg = 1;
7426 sdp->isp_req_ack_active_neg =
7427 (mbs.param[1] >> 4) & 0x1;
7428 sdp->isp_data_line_active_neg =
7429 (mbs.param[1] >> 5) & 0x1;
7431 sdp1->isp_req_ack_active_neg =
7432 (mbs.param[2] >> 4) & 0x1;
7433 sdp1->isp_data_line_active_neg =
7434 (mbs.param[2] >> 5) & 0x1;
7442 isp_setdfltfcparm(ispsoftc_t *isp, int chan)
7444 fcparam *fcp = FCPARAM(isp, chan);
7447 * Establish some default parameters.
7449 fcp->role = DEFAULT_ROLE(isp, chan);
7450 fcp->isp_maxalloc = ICB_DFLT_ALLOC;
7451 fcp->isp_retry_delay = ICB_DFLT_RDELAY;
7452 fcp->isp_retry_count = ICB_DFLT_RCOUNT;
7453 fcp->isp_loopid = DEFAULT_LOOPID(isp, chan);
7454 fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp, chan);
7455 fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp, chan);
7456 fcp->isp_fwoptions = 0;
7457 fcp->isp_xfwoptions = 0;
7458 fcp->isp_zfwoptions = 0;
7459 fcp->isp_lasthdl = NIL_HANDLE;
7460 fcp->isp_login_hdl = NIL_HANDLE;
7463 fcp->isp_fwoptions |= ICB2400_OPT1_FAIRNESS;
7464 fcp->isp_fwoptions |= ICB2400_OPT1_HARD_ADDRESS;
7465 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
7466 fcp->isp_fwoptions |= ICB2400_OPT1_FULL_DUPLEX;
7467 fcp->isp_fwoptions |= ICB2400_OPT1_BOTH_WWNS;
7468 fcp->isp_xfwoptions |= ICB2400_OPT2_LOOP_2_PTP;
7469 fcp->isp_zfwoptions |= ICB2400_OPT3_RATE_AUTO;
7471 fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
7472 fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
7473 fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
7474 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
7475 fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
7477 * Make sure this is turned off now until we get
7478 * extended options from NVRAM
7480 fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
7481 fcp->isp_xfwoptions |= ICBXOPT_LOOP_2_PTP;
7482 fcp->isp_zfwoptions |= ICBZOPT_RATE_AUTO;
7487 * Now try and read NVRAM unless told to not do so.
7488 * This will set fcparam's isp_wwnn_nvram && isp_wwpn_nvram.
7490 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7493 * Give a couple of tries at reading NVRAM.
7495 for (i = 0; i < 2; i++) {
7496 j = isp_read_nvram(isp, chan);
7502 isp->isp_confopts |= ISP_CFG_NONVRAM;
7506 fcp->isp_wwnn = ACTIVE_NODEWWN(isp, chan);
7507 fcp->isp_wwpn = ACTIVE_PORTWWN(isp, chan);
7508 isp_prt(isp, ISP_LOGCONFIG, "Chan %d 0x%08x%08x/0x%08x%08x Role %s",
7509 chan, (uint32_t) (fcp->isp_wwnn >> 32), (uint32_t) (fcp->isp_wwnn),
7510 (uint32_t) (fcp->isp_wwpn >> 32), (uint32_t) (fcp->isp_wwpn),
7511 isp_class3_roles[fcp->role]);
7515 * Re-initialize the ISP and complete all orphaned commands
7516 * with a 'botched' notice. The reset/init routines should
7517 * not disturb an already active list of commands.
7521 isp_reinit(ispsoftc_t *isp, int do_load_defaults)
7525 if (isp->isp_state > ISP_RESETSTATE)
7527 if (isp->isp_state != ISP_RESETSTATE)
7528 isp_reset(isp, do_load_defaults);
7529 if (isp->isp_state != ISP_RESETSTATE) {
7531 isp_prt(isp, ISP_LOGERR, "%s: cannot reset card", __func__);
7536 if (isp->isp_state > ISP_RESETSTATE &&
7537 isp->isp_state != ISP_RUNSTATE) {
7539 isp_prt(isp, ISP_LOGERR, "%s: cannot init card", __func__);
7540 ISP_DISABLE_INTS(isp);
7543 * If we're in ISP_ROLE_NONE, turn off the lasers.
7545 if (!IS_24XX(isp)) {
7546 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
7547 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
7548 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
7549 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
7550 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
7556 isp_clear_commands(isp);
7558 for (i = 0; i < isp->isp_nchan; i++)
7559 isp_clear_portdb(isp, i);
7568 isp_read_nvram(ispsoftc_t *isp, int bus)
7571 uint8_t csum, minversion;
7573 uint8_t _x[ISP2400_NVRAM_SIZE];
7574 uint16_t _s[ISP2400_NVRAM_SIZE>>1];
7576 #define nvram_data _n._x
7577 #define nvram_words _n._s
7580 return (isp_read_nvram_2400(isp, nvram_data));
7581 } else if (IS_FC(isp)) {
7582 amt = ISP2100_NVRAM_SIZE;
7584 } else if (IS_ULTRA2(isp)) {
7585 amt = ISP1080_NVRAM_SIZE;
7588 amt = ISP_NVRAM_SIZE;
7592 for (i = 0; i < amt>>1; i++) {
7593 isp_rdnvram_word(isp, i, &nvram_words[i]);
7596 if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7597 nvram_data[2] != 'P') {
7598 if (isp->isp_bustype != ISP_BT_SBUS) {
7599 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
7600 isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x", nvram_data[0], nvram_data[1], nvram_data[2]);
7606 for (csum = 0, i = 0; i < amt; i++) {
7607 csum += nvram_data[i];
7610 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7615 if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
7616 isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
7617 ISP_NVRAM_VERSION(nvram_data));
7622 if (IS_ULTRA3(isp)) {
7623 isp_parse_nvram_12160(isp, bus, nvram_data);
7624 } else if (IS_1080(isp)) {
7625 isp_parse_nvram_1080(isp, bus, nvram_data);
7626 } else if (IS_1280(isp) || IS_1240(isp)) {
7627 isp_parse_nvram_1080(isp, bus, nvram_data);
7628 } else if (IS_SCSI(isp)) {
7629 isp_parse_nvram_1020(isp, nvram_data);
7631 isp_parse_nvram_2100(isp, nvram_data);
7641 isp_read_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
7644 uint32_t addr, csum, lwrds, *dptr;
7646 if (isp->isp_port) {
7647 addr = ISP2400_NVRAM_PORT1_ADDR;
7649 addr = ISP2400_NVRAM_PORT0_ADDR;
7652 dptr = (uint32_t *) nvram_data;
7653 for (lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7654 isp_rd_2400_nvram(isp, addr++, dptr++);
7656 if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7657 nvram_data[2] != 'P') {
7658 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header (%x %x %x)",
7659 nvram_data[0], nvram_data[1], nvram_data[2]);
7663 dptr = (uint32_t *) nvram_data;
7664 for (csum = 0, lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7666 ISP_IOXGET_32(isp, &dptr[lwrds], tmp);
7670 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7674 isp_parse_nvram_2400(isp, nvram_data);
7680 isp_rdnvram_word(ispsoftc_t *isp, int wo, uint16_t *rp)
7683 uint16_t bit, rqst, junk;
7685 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7687 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7691 wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
7692 if (IS_2312(isp) && isp->isp_port) {
7695 rqst = (ISP_NVRAM_READ << 8) | wo;
7697 } else if (IS_ULTRA2(isp)) {
7698 wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1);
7699 rqst = (ISP_NVRAM_READ << 8) | wo;
7702 wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
7703 rqst = (ISP_NVRAM_READ << 6) | wo;
7708 * Clock the word select request out...
7710 for (i = cbits; i >= 0; i--) {
7711 if ((rqst >> i) & 1) {
7712 bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
7714 bit = BIU_NVRAM_SELECT;
7716 ISP_WRITE(isp, BIU_NVRAM, bit);
7718 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7719 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
7721 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7722 ISP_WRITE(isp, BIU_NVRAM, bit);
7724 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7727 * Now read the result back in (bits come back in MSB format).
7730 for (i = 0; i < 16; i++) {
7733 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7735 rv = ISP_READ(isp, BIU_NVRAM);
7736 if (rv & BIU_NVRAM_DATAIN) {
7740 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7742 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7744 ISP_WRITE(isp, BIU_NVRAM, 0);
7746 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7747 ISP_SWIZZLE_NVRAM_WORD(isp, rp);
7751 isp_rd_2400_nvram(ispsoftc_t *isp, uint32_t addr, uint32_t *rp)
7754 uint32_t base = 0x7ffe0000;
7758 base = 0x7fe7c000; /* XXX: Observation, may be wrong. */
7759 } else if (IS_25XX(isp)) {
7760 base = 0x7ff00000 | 0x48000;
7762 ISP_WRITE(isp, BIU2400_FLASH_ADDR, base | addr);
7763 for (loops = 0; loops < 5000; loops++) {
7765 tmp = ISP_READ(isp, BIU2400_FLASH_ADDR);
7766 if ((tmp & (1U << 31)) != 0) {
7770 if (tmp & (1U << 31)) {
7771 *rp = ISP_READ(isp, BIU2400_FLASH_DATA);
7772 ISP_SWIZZLE_NVRAM_LONG(isp, rp);
7779 isp_parse_nvram_1020(ispsoftc_t *isp, uint8_t *nvram_data)
7781 sdparam *sdp = SDPARAM(isp, 0);
7784 sdp->isp_fifo_threshold =
7785 ISP_NVRAM_FIFO_THRESHOLD(nvram_data) |
7786 (ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2);
7788 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7789 sdp->isp_initiator_id = ISP_NVRAM_INITIATOR_ID(nvram_data);
7791 sdp->isp_bus_reset_delay =
7792 ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
7794 sdp->isp_retry_count =
7795 ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
7797 sdp->isp_retry_delay =
7798 ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
7800 sdp->isp_async_data_setup =
7801 ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
7803 if (isp->isp_type >= ISP_HA_SCSI_1040) {
7804 if (sdp->isp_async_data_setup < 9) {
7805 sdp->isp_async_data_setup = 9;
7808 if (sdp->isp_async_data_setup != 6) {
7809 sdp->isp_async_data_setup = 6;
7813 sdp->isp_req_ack_active_neg =
7814 ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
7816 sdp->isp_data_line_active_neg =
7817 ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
7819 sdp->isp_data_dma_burst_enabl =
7820 ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
7822 sdp->isp_cmd_dma_burst_enable =
7823 ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
7825 sdp->isp_tag_aging =
7826 ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
7828 sdp->isp_selection_timeout =
7829 ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
7831 sdp->isp_max_queue_depth =
7832 ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
7834 sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
7836 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7837 sdp->isp_devparam[tgt].dev_enable =
7838 ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt);
7839 sdp->isp_devparam[tgt].exc_throttle =
7840 ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt);
7841 sdp->isp_devparam[tgt].nvrm_offset =
7842 ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt);
7843 sdp->isp_devparam[tgt].nvrm_period =
7844 ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt);
7846 * We probably shouldn't lie about this, but it
7847 * it makes it much safer if we limit NVRAM values
7850 if (isp->isp_type < ISP_HA_SCSI_1040) {
7852 * If we're not ultra, we can't possibly
7853 * be a shorter period than this.
7855 if (sdp->isp_devparam[tgt].nvrm_period < 0x19) {
7856 sdp->isp_devparam[tgt].nvrm_period = 0x19;
7858 if (sdp->isp_devparam[tgt].nvrm_offset > 0xc) {
7859 sdp->isp_devparam[tgt].nvrm_offset = 0x0c;
7862 if (sdp->isp_devparam[tgt].nvrm_offset > 0x8) {
7863 sdp->isp_devparam[tgt].nvrm_offset = 0x8;
7866 sdp->isp_devparam[tgt].nvrm_flags = 0;
7867 if (ISP_NVRAM_TGT_RENEG(nvram_data, tgt))
7868 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7869 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7870 if (ISP_NVRAM_TGT_TQING(nvram_data, tgt))
7871 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7872 if (ISP_NVRAM_TGT_SYNC(nvram_data, tgt))
7873 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7874 if (ISP_NVRAM_TGT_WIDE(nvram_data, tgt))
7875 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7876 if (ISP_NVRAM_TGT_PARITY(nvram_data, tgt))
7877 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7878 if (ISP_NVRAM_TGT_DISC(nvram_data, tgt))
7879 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7880 sdp->isp_devparam[tgt].actv_flags = 0; /* we don't know */
7881 sdp->isp_devparam[tgt].goal_offset =
7882 sdp->isp_devparam[tgt].nvrm_offset;
7883 sdp->isp_devparam[tgt].goal_period =
7884 sdp->isp_devparam[tgt].nvrm_period;
7885 sdp->isp_devparam[tgt].goal_flags =
7886 sdp->isp_devparam[tgt].nvrm_flags;
7891 isp_parse_nvram_1080(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7893 sdparam *sdp = SDPARAM(isp, bus);
7896 sdp->isp_fifo_threshold =
7897 ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data);
7899 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7900 sdp->isp_initiator_id = ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus);
7902 sdp->isp_bus_reset_delay =
7903 ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7905 sdp->isp_retry_count =
7906 ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7908 sdp->isp_retry_delay =
7909 ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7911 sdp->isp_async_data_setup =
7912 ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7914 sdp->isp_req_ack_active_neg =
7915 ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7917 sdp->isp_data_line_active_neg =
7918 ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7920 sdp->isp_data_dma_burst_enabl =
7921 ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7923 sdp->isp_cmd_dma_burst_enable =
7924 ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7926 sdp->isp_selection_timeout =
7927 ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
7929 sdp->isp_max_queue_depth =
7930 ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
7932 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7933 sdp->isp_devparam[tgt].dev_enable =
7934 ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
7935 sdp->isp_devparam[tgt].exc_throttle =
7936 ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
7937 sdp->isp_devparam[tgt].nvrm_offset =
7938 ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
7939 sdp->isp_devparam[tgt].nvrm_period =
7940 ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
7941 sdp->isp_devparam[tgt].nvrm_flags = 0;
7942 if (ISP1080_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
7943 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7944 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7945 if (ISP1080_NVRAM_TGT_TQING(nvram_data, tgt, bus))
7946 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7947 if (ISP1080_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
7948 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7949 if (ISP1080_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
7950 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7951 if (ISP1080_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
7952 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7953 if (ISP1080_NVRAM_TGT_DISC(nvram_data, tgt, bus))
7954 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7955 sdp->isp_devparam[tgt].actv_flags = 0;
7956 sdp->isp_devparam[tgt].goal_offset =
7957 sdp->isp_devparam[tgt].nvrm_offset;
7958 sdp->isp_devparam[tgt].goal_period =
7959 sdp->isp_devparam[tgt].nvrm_period;
7960 sdp->isp_devparam[tgt].goal_flags =
7961 sdp->isp_devparam[tgt].nvrm_flags;
7966 isp_parse_nvram_12160(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7968 sdparam *sdp = SDPARAM(isp, bus);
7971 sdp->isp_fifo_threshold =
7972 ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data);
7974 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7975 sdp->isp_initiator_id = ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus);
7977 sdp->isp_bus_reset_delay =
7978 ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7980 sdp->isp_retry_count =
7981 ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7983 sdp->isp_retry_delay =
7984 ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7986 sdp->isp_async_data_setup =
7987 ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7989 sdp->isp_req_ack_active_neg =
7990 ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7992 sdp->isp_data_line_active_neg =
7993 ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7995 sdp->isp_data_dma_burst_enabl =
7996 ISP12160_NVRAM_BURST_ENABLE(nvram_data);
7998 sdp->isp_cmd_dma_burst_enable =
7999 ISP12160_NVRAM_BURST_ENABLE(nvram_data);
8001 sdp->isp_selection_timeout =
8002 ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
8004 sdp->isp_max_queue_depth =
8005 ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
8007 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
8008 sdp->isp_devparam[tgt].dev_enable =
8009 ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
8010 sdp->isp_devparam[tgt].exc_throttle =
8011 ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
8012 sdp->isp_devparam[tgt].nvrm_offset =
8013 ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
8014 sdp->isp_devparam[tgt].nvrm_period =
8015 ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
8016 sdp->isp_devparam[tgt].nvrm_flags = 0;
8017 if (ISP12160_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
8018 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
8019 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
8020 if (ISP12160_NVRAM_TGT_TQING(nvram_data, tgt, bus))
8021 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
8022 if (ISP12160_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
8023 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
8024 if (ISP12160_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
8025 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
8026 if (ISP12160_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
8027 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
8028 if (ISP12160_NVRAM_TGT_DISC(nvram_data, tgt, bus))
8029 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
8030 sdp->isp_devparam[tgt].actv_flags = 0;
8031 sdp->isp_devparam[tgt].goal_offset =
8032 sdp->isp_devparam[tgt].nvrm_offset;
8033 sdp->isp_devparam[tgt].goal_period =
8034 sdp->isp_devparam[tgt].nvrm_period;
8035 sdp->isp_devparam[tgt].goal_flags =
8036 sdp->isp_devparam[tgt].nvrm_flags;
8041 isp_parse_nvram_2100(ispsoftc_t *isp, uint8_t *nvram_data)
8043 fcparam *fcp = FCPARAM(isp, 0);
8047 * There is NVRAM storage for both Port and Node entities-
8048 * but the Node entity appears to be unused on all the cards
8049 * I can find. However, we should account for this being set
8050 * at some point in the future.
8052 * Qlogic WWNs have an NAA of 2, but usually nothing shows up in
8053 * bits 48..60. In the case of the 2202, it appears that they do
8054 * use bit 48 to distinguish between the two instances on the card.
8055 * The 2204, which I've never seen, *probably* extends this method.
8057 wwn = ISP2100_NVRAM_PORT_NAME(nvram_data);
8059 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
8060 (uint32_t) (wwn >> 32), (uint32_t) (wwn));
8061 if ((wwn >> 60) == 0) {
8062 wwn |= (((uint64_t) 2)<< 60);
8065 fcp->isp_wwpn_nvram = wwn;
8066 if (IS_2200(isp) || IS_23XX(isp)) {
8067 wwn = ISP2100_NVRAM_NODE_NAME(nvram_data);
8069 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
8070 (uint32_t) (wwn >> 32),
8072 if ((wwn >> 60) == 0) {
8073 wwn |= (((uint64_t) 2)<< 60);
8076 wwn = fcp->isp_wwpn_nvram & ~((uint64_t) 0xfff << 48);
8079 wwn &= ~((uint64_t) 0xfff << 48);
8081 fcp->isp_wwnn_nvram = wwn;
8083 fcp->isp_maxalloc = ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
8084 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8085 DEFAULT_FRAMESIZE(isp) =
8086 ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
8088 fcp->isp_retry_delay = ISP2100_NVRAM_RETRY_DELAY(nvram_data);
8089 fcp->isp_retry_count = ISP2100_NVRAM_RETRY_COUNT(nvram_data);
8090 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8091 fcp->isp_loopid = ISP2100_NVRAM_HARDLOOPID(nvram_data);
8093 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8094 DEFAULT_EXEC_THROTTLE(isp) =
8095 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
8097 fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
8098 isp_prt(isp, ISP_LOGDEBUG0,
8099 "NVRAM 0x%08x%08x 0x%08x%08x maxalloc %d maxframelen %d",
8100 (uint32_t) (fcp->isp_wwnn_nvram >> 32),
8101 (uint32_t) fcp->isp_wwnn_nvram,
8102 (uint32_t) (fcp->isp_wwpn_nvram >> 32),
8103 (uint32_t) fcp->isp_wwpn_nvram,
8104 ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data),
8105 ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data));
8106 isp_prt(isp, ISP_LOGDEBUG0,
8107 "execthrottle %d fwoptions 0x%x hardloop %d tov %d",
8108 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data),
8109 ISP2100_NVRAM_OPTIONS(nvram_data),
8110 ISP2100_NVRAM_HARDLOOPID(nvram_data),
8111 ISP2100_NVRAM_TOV(nvram_data));
8112 fcp->isp_xfwoptions = ISP2100_XFW_OPTIONS(nvram_data);
8113 fcp->isp_zfwoptions = ISP2100_ZFW_OPTIONS(nvram_data);
8114 isp_prt(isp, ISP_LOGDEBUG0, "xfwoptions 0x%x zfw options 0x%x",
8115 ISP2100_XFW_OPTIONS(nvram_data), ISP2100_ZFW_OPTIONS(nvram_data));
8119 isp_parse_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
8121 fcparam *fcp = FCPARAM(isp, 0);
8124 isp_prt(isp, ISP_LOGDEBUG0,
8125 "NVRAM 0x%08x%08x 0x%08x%08x exchg_cnt %d maxframelen %d",
8126 (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data) >> 32),
8127 (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data)),
8128 (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data) >> 32),
8129 (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data)),
8130 ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data),
8131 ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data));
8132 isp_prt(isp, ISP_LOGDEBUG0,
8133 "NVRAM execthr %d loopid %d fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
8134 ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data),
8135 ISP2400_NVRAM_HARDLOOPID(nvram_data),
8136 ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data),
8137 ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data),
8138 ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data));
8140 wwn = ISP2400_NVRAM_PORT_NAME(nvram_data);
8141 fcp->isp_wwpn_nvram = wwn;
8143 wwn = ISP2400_NVRAM_NODE_NAME(nvram_data);
8145 if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
8149 if (wwn == 0 && (fcp->isp_wwpn_nvram >> 60) == 2) {
8150 wwn = fcp->isp_wwpn_nvram;
8151 wwn &= ~((uint64_t) 0xfff << 48);
8153 fcp->isp_wwnn_nvram = wwn;
8155 if (ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data)) {
8156 fcp->isp_maxalloc = ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data);
8158 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8159 DEFAULT_FRAMESIZE(isp) =
8160 ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data);
8162 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8163 fcp->isp_loopid = ISP2400_NVRAM_HARDLOOPID(nvram_data);
8165 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8166 DEFAULT_EXEC_THROTTLE(isp) =
8167 ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data);
8169 fcp->isp_fwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data);
8170 fcp->isp_xfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data);
8171 fcp->isp_zfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data);