2 * Copyright (c) 2009-2017 Alexander Motin <mav@FreeBSD.org>
3 * Copyright (c) 1997-2009 by Matthew Jacob
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * Machine and OS Independent (well, as best as possible)
32 * code for the Qlogic ISP SCSI and FC-SCSI adapters.
36 * Inspiration and ideas about this driver are from Erik Moe's Linux driver
37 * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
38 * ideas dredged from the Solaris driver.
42 * Include header file appropriate for platform we're building on.
45 #include <sys/cdefs.h>
46 __KERNEL_RCSID(0, "$NetBSD$");
47 #include <dev/ic/isp_netbsd.h>
50 #include <sys/cdefs.h>
51 __FBSDID("$FreeBSD$");
52 #include <dev/isp/isp_freebsd.h>
55 #include <dev/ic/isp_openbsd.h>
58 #include "isp_linux.h"
61 #include "isp_solaris.h"
67 #define MBOX_DELAY_COUNT 1000000 / 100
72 static const char notresp[] = "Unknown IOCB in RESPONSE Queue (type 0x%x) @ idx %d (next %d)";
73 static const char bun[] = "bad underrun (count %d, resid %d, status %s)";
74 static const char lipd[] = "Chan %d LIP destroyed %d active commands";
75 static const char sacq[] = "unable to acquire scratch area";
77 static const uint8_t alpa_map[] = {
78 0xef, 0xe8, 0xe4, 0xe2, 0xe1, 0xe0, 0xdc, 0xda,
79 0xd9, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xce,
80 0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc7, 0xc6, 0xc5,
81 0xc3, 0xbc, 0xba, 0xb9, 0xb6, 0xb5, 0xb4, 0xb3,
82 0xb2, 0xb1, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9,
83 0xa7, 0xa6, 0xa5, 0xa3, 0x9f, 0x9e, 0x9d, 0x9b,
84 0x98, 0x97, 0x90, 0x8f, 0x88, 0x84, 0x82, 0x81,
85 0x80, 0x7c, 0x7a, 0x79, 0x76, 0x75, 0x74, 0x73,
86 0x72, 0x71, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69,
87 0x67, 0x66, 0x65, 0x63, 0x5c, 0x5a, 0x59, 0x56,
88 0x55, 0x54, 0x53, 0x52, 0x51, 0x4e, 0x4d, 0x4c,
89 0x4b, 0x4a, 0x49, 0x47, 0x46, 0x45, 0x43, 0x3c,
90 0x3a, 0x39, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31,
91 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x27, 0x26,
92 0x25, 0x23, 0x1f, 0x1e, 0x1d, 0x1b, 0x18, 0x17,
93 0x10, 0x0f, 0x08, 0x04, 0x02, 0x01, 0x00
97 * Local function prototypes.
99 static void isp_parse_async(ispsoftc_t *, uint16_t);
100 static void isp_parse_async_fc(ispsoftc_t *, uint16_t);
101 static int isp_handle_other_response(ispsoftc_t *, int, isphdr_t *, uint32_t *);
102 static void isp_parse_status(ispsoftc_t *, ispstatusreq_t *, XS_T *, uint32_t *);
103 static void isp_parse_status_24xx(ispsoftc_t *, isp24xx_statusreq_t *, XS_T *, uint32_t *);
104 static void isp_fastpost_complete(ispsoftc_t *, uint32_t);
105 static void isp_scsi_init(ispsoftc_t *);
106 static void isp_scsi_channel_init(ispsoftc_t *, int);
107 static void isp_fibre_init(ispsoftc_t *);
108 static void isp_fibre_init_2400(ispsoftc_t *);
109 static void isp_clear_portdb(ispsoftc_t *, int);
110 static void isp_mark_portdb(ispsoftc_t *, int);
111 static int isp_plogx(ispsoftc_t *, int, uint16_t, uint32_t, int);
112 static int isp_port_login(ispsoftc_t *, uint16_t, uint32_t);
113 static int isp_port_logout(ispsoftc_t *, uint16_t, uint32_t);
114 static int isp_getpdb(ispsoftc_t *, int, uint16_t, isp_pdb_t *);
115 static int isp_gethandles(ispsoftc_t *, int, uint16_t *, int *, int);
116 static void isp_dump_chip_portdb(ispsoftc_t *, int);
117 static uint64_t isp_get_wwn(ispsoftc_t *, int, int, int);
118 static int isp_fclink_test(ispsoftc_t *, int, int);
119 static int isp_pdb_sync(ispsoftc_t *, int);
120 static int isp_scan_loop(ispsoftc_t *, int);
121 static int isp_gid_pt(ispsoftc_t *, int);
122 static int isp_scan_fabric(ispsoftc_t *, int);
123 static int isp_login_device(ispsoftc_t *, int, uint32_t, isp_pdb_t *, uint16_t *);
124 static int isp_send_change_request(ispsoftc_t *, int);
125 static int isp_register_fc4_type(ispsoftc_t *, int);
126 static int isp_register_fc4_features_24xx(ispsoftc_t *, int);
127 static int isp_register_port_name_24xx(ispsoftc_t *, int);
128 static int isp_register_node_name_24xx(ispsoftc_t *, int);
129 static uint16_t isp_next_handle(ispsoftc_t *, uint16_t *);
130 static int isp_fw_state(ispsoftc_t *, int);
131 static void isp_mboxcmd(ispsoftc_t *, mbreg_t *);
133 static void isp_spi_update(ispsoftc_t *, int);
134 static void isp_setdfltsdparm(ispsoftc_t *);
135 static void isp_setdfltfcparm(ispsoftc_t *, int);
136 static int isp_read_nvram(ispsoftc_t *, int);
137 static int isp_read_nvram_2400(ispsoftc_t *, uint8_t *);
138 static void isp_rdnvram_word(ispsoftc_t *, int, uint16_t *);
139 static void isp_rd_2400_nvram(ispsoftc_t *, uint32_t, uint32_t *);
140 static void isp_parse_nvram_1020(ispsoftc_t *, uint8_t *);
141 static void isp_parse_nvram_1080(ispsoftc_t *, int, uint8_t *);
142 static void isp_parse_nvram_12160(ispsoftc_t *, int, uint8_t *);
143 static void isp_parse_nvram_2100(ispsoftc_t *, uint8_t *);
144 static void isp_parse_nvram_2400(ispsoftc_t *, uint8_t *);
147 isp_change_fw_state(ispsoftc_t *isp, int chan, int state)
149 fcparam *fcp = FCPARAM(isp, chan);
151 if (fcp->isp_fwstate == state)
153 isp_prt(isp, ISP_LOGCONFIG|ISP_LOG_SANCFG,
154 "Chan %d Firmware state <%s->%s>", chan,
155 isp_fc_fw_statename(fcp->isp_fwstate), isp_fc_fw_statename(state));
156 fcp->isp_fwstate = state;
162 * Hit the chip over the head, download new f/w if available and set it running.
164 * Locking done elsewhere.
168 isp_reset(ispsoftc_t *isp, int do_load_defaults)
173 uint32_t code_org, val;
174 int loops, i, dodnld = 1;
175 const char *btype = "????";
176 static const char dcrc[] = "Downloaded RISC Code Checksum Failure";
179 * Basic types (SCSI, FibreChannel and PCI or SBus)
180 * have been set in the MD code. We figure out more
181 * here. Possibly more refined types based upon PCI
182 * identification. Chip revision has been gathered.
184 * After we've fired this chip up, zero out the conf1 register
185 * for SCSI adapters and do other settings for the 2100.
188 isp->isp_state = ISP_NILSTATE;
189 ISP_DISABLE_INTS(isp);
192 * Put the board into PAUSE mode (so we can read the SXP registers
193 * or write FPM/FBM registers).
196 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_HOST_INT);
197 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
198 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
200 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
204 switch (isp->isp_type) {
235 * While we're paused, reset the FPM module and FBM
238 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
239 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
240 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
241 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
242 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
244 } else if (IS_1240(isp)) {
249 sdp = SDPARAM(isp, 0);
250 sdp->isp_ultramode = 1;
251 sdp = SDPARAM(isp, 1);
252 sdp->isp_ultramode = 1;
254 * XXX: Should probably do some bus sensing.
256 } else if (IS_ULTRA3(isp)) {
257 sdparam *sdp = isp->isp_param;
259 isp->isp_clock = 100;
263 else if (IS_12160(isp))
267 sdp->isp_lvdmode = 1;
269 if (IS_DUALBUS(isp)) {
271 sdp->isp_lvdmode = 1;
273 } else if (IS_ULTRA2(isp)) {
274 static const char m[] = "bus %d is in %s Mode";
276 sdparam *sdp = SDPARAM(isp, 0);
278 isp->isp_clock = 100;
282 else if (IS_1080(isp))
287 l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
289 case ISP1080_LVD_MODE:
290 sdp->isp_lvdmode = 1;
291 isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
293 case ISP1080_HVD_MODE:
294 sdp->isp_diffmode = 1;
295 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
297 case ISP1080_SE_MODE:
298 sdp->isp_ultramode = 1;
299 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
302 isp_prt(isp, ISP_LOGERR,
303 "unknown mode on bus %d (0x%x)", 0, l);
307 if (IS_DUALBUS(isp)) {
308 sdp = SDPARAM(isp, 1);
309 l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
310 l &= ISP1080_MODE_MASK;
312 case ISP1080_LVD_MODE:
313 sdp->isp_lvdmode = 1;
314 isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
316 case ISP1080_HVD_MODE:
317 sdp->isp_diffmode = 1;
318 isp_prt(isp, ISP_LOGCONFIG,
319 m, 1, "Differential");
321 case ISP1080_SE_MODE:
322 sdp->isp_ultramode = 1;
323 isp_prt(isp, ISP_LOGCONFIG,
324 m, 1, "Single-Ended");
327 isp_prt(isp, ISP_LOGERR,
328 "unknown mode on bus %d (0x%x)", 1, l);
333 sdparam *sdp = SDPARAM(isp, 0);
334 i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
337 isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
341 isp->isp_type = ISP_HA_SCSI_1020;
346 * Some 1020A chips are Ultra Capable, but don't
347 * run the clock rate up for that unless told to
348 * do so by the Ultra Capable bits being set.
351 isp->isp_type = ISP_HA_SCSI_1020A;
356 isp->isp_type = ISP_HA_SCSI_1040;
361 isp->isp_type = ISP_HA_SCSI_1040A;
366 isp->isp_type = ISP_HA_SCSI_1040B;
371 isp->isp_type = ISP_HA_SCSI_1040C;
376 * Now, while we're at it, gather info about ultra
377 * and/or differential mode.
379 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
380 isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
381 sdp->isp_diffmode = 1;
383 sdp->isp_diffmode = 0;
385 i = ISP_READ(isp, RISC_PSR);
386 if (isp->isp_bustype == ISP_BT_SBUS) {
387 i &= RISC_PSR_SBUS_ULTRA;
389 i &= RISC_PSR_PCI_ULTRA;
392 isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
393 sdp->isp_ultramode = 1;
395 * If we're in Ultra Mode, we have to be 60MHz clock-
396 * even for the SBus version.
400 sdp->isp_ultramode = 0;
402 * Clock is known. Gronk.
407 * Machine dependent clock (if set) overrides
408 * our generic determinations.
410 if (isp->isp_mdvec->dv_clock) {
411 if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
412 isp->isp_clock = isp->isp_mdvec->dv_clock;
418 * Hit the chip over the head with hammer,
419 * and give it a chance to recover.
423 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
430 * Clear data && control DMA engines.
432 ISP_WRITE(isp, CDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
433 ISP_WRITE(isp, DDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
436 } else if (IS_24XX(isp)) {
438 * Stop DMA and wait for it to stop.
440 ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
441 for (val = loops = 0; loops < 30000; loops++) {
443 val = ISP_READ(isp, BIU2400_CSR);
444 if ((val & BIU2400_DMA_ACTIVE) == 0) {
448 if (val & BIU2400_DMA_ACTIVE) {
449 isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
453 * Hold it in SOFT_RESET and STOP state for 100us.
455 ISP_WRITE(isp, BIU2400_CSR, BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
457 for (loops = 0; loops < 10000; loops++) {
459 val = ISP_READ(isp, OUTMAILBOX0);
461 for (val = loops = 0; loops < 500000; loops ++) {
462 val = ISP_READ(isp, BIU2400_CSR);
463 if ((val & BIU2400_SOFT_RESET) == 0) {
467 if (val & BIU2400_SOFT_RESET) {
468 isp_prt(isp, ISP_LOGERR, "Failed to come out of reset");
472 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
479 * Clear data && control DMA engines.
481 ISP_WRITE(isp, CDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
482 ISP_WRITE(isp, TDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
483 ISP_WRITE(isp, RDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
487 * Wait for ISP to be ready to go...
489 loops = MBOX_DELAY_COUNT;
492 if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) {
495 } else if (IS_24XX(isp)) {
496 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
500 if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
505 ISP_DUMPREGS(isp, "chip reset timed out");
511 * After we've fired this chip up, zero out the conf1 register
512 * for SCSI adapters and other settings for the 2100.
516 ISP_WRITE(isp, BIU_CONF1, 0);
517 } else if (!IS_24XX(isp)) {
518 ISP_WRITE(isp, BIU2100_CSR, 0);
522 * Reset RISC Processor
525 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
526 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
527 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
529 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
531 ISP_WRITE(isp, BIU_SEMA, 0);
535 * Post-RISC Reset stuff.
538 for (val = loops = 0; loops < 5000000; loops++) {
540 val = ISP_READ(isp, OUTMAILBOX0);
546 isp_prt(isp, ISP_LOGERR, "reset didn't clear");
549 } else if (IS_SCSI(isp)) {
550 uint16_t tmp = isp->isp_mdvec->dv_conf1;
552 * Busted FIFO. Turn off all but burst enables.
554 if (isp->isp_type == ISP_HA_SCSI_1040A) {
555 tmp &= BIU_BURST_ENABLE;
557 ISP_SETBITS(isp, BIU_CONF1, tmp);
558 if (tmp & BIU_BURST_ENABLE) {
559 ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
560 ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
562 if (SDPARAM(isp, 0)->isp_ptisp) {
563 if (SDPARAM(isp, 0)->isp_ultramode) {
564 while (ISP_READ(isp, RISC_MTR) != 0x1313) {
565 ISP_WRITE(isp, RISC_MTR, 0x1313);
566 ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
569 ISP_WRITE(isp, RISC_MTR, 0x1212);
572 * PTI specific register
574 ISP_WRITE(isp, RISC_EMB, DUAL_BANK);
576 ISP_WRITE(isp, RISC_MTR, 0x1212);
578 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
580 ISP_WRITE(isp, RISC_MTR2100, 0x1212);
581 if (IS_2200(isp) || IS_23XX(isp)) {
582 ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
584 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
588 * Set up default request/response queue in-pointer/out-pointer
592 isp->isp_rqstinrp = BIU2400_REQINP;
593 isp->isp_rqstoutrp = BIU2400_REQOUTP;
594 isp->isp_respinrp = BIU2400_RSPINP;
595 isp->isp_respoutrp = BIU2400_RSPOUTP;
596 } else if (IS_23XX(isp)) {
597 isp->isp_rqstinrp = BIU_REQINP;
598 isp->isp_rqstoutrp = BIU_REQOUTP;
599 isp->isp_respinrp = BIU_RSPINP;
600 isp->isp_respoutrp = BIU_RSPOUTP;
602 isp->isp_rqstinrp = INMAILBOX4;
603 isp->isp_rqstoutrp = OUTMAILBOX4;
604 isp->isp_respinrp = OUTMAILBOX5;
605 isp->isp_respoutrp = INMAILBOX5;
607 ISP_WRITE(isp, isp->isp_rqstinrp, 0);
608 ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
609 ISP_WRITE(isp, isp->isp_respinrp, 0);
610 ISP_WRITE(isp, isp->isp_respoutrp, 0);
613 ISP_WRITE(isp, BIU2400_PRI_REQINP, 0);
614 ISP_WRITE(isp, BIU2400_PRI_REQOUTP, 0);
616 ISP_WRITE(isp, BIU2400_ATIO_RSPINP, 0);
617 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, 0);
620 if (!IS_24XX(isp) && isp->isp_bustype == ISP_BT_PCI) {
621 /* Make sure the BIOS is disabled */
622 ISP_WRITE(isp, HCCR, PCI_HCCR_CMD_BIOS);
626 * Wait for everything to finish firing up.
628 * Avoid doing this on early 2312s because you can generate a PCI
629 * parity error (chip breakage).
631 if (IS_2312(isp) && isp->isp_revision < 2) {
634 loops = MBOX_DELAY_COUNT;
635 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
638 isp_prt(isp, ISP_LOGERR, "MBOX_BUSY never cleared on reset");
645 * Up until this point we've done everything by just reading or
646 * setting registers. From this point on we rely on at least *some*
647 * kind of firmware running in the card.
651 * Do some sanity checking by running a NOP command.
652 * If it succeeds, the ROM firmware is now running.
654 MBSINIT(&mbs, MBOX_NO_OP, MBLOGALL, 0);
655 isp_mboxcmd(isp, &mbs);
656 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
657 isp_prt(isp, ISP_LOGERR, "NOP command failed (%x)", mbs.param[0]);
662 * Do some operational tests
664 if (IS_SCSI(isp) || IS_24XX(isp)) {
665 static const uint16_t patterns[MAX_MAILBOX] = {
666 0x0000, 0xdead, 0xbeef, 0xffff,
667 0xa5a5, 0x5a5a, 0x7f7f, 0x7ff7,
668 0x3421, 0xabcd, 0xdcba, 0xfeef,
669 0xbead, 0xdebe, 0x2222, 0x3333,
670 0x5555, 0x6666, 0x7777, 0xaaaa,
671 0xffff, 0xdddd, 0x9999, 0x1fbc,
672 0x6666, 0x6677, 0x1122, 0x33ff,
673 0x0000, 0x0001, 0x1000, 0x1010,
675 int nmbox = ISP_NMBOX(isp);
678 MBSINIT(&mbs, MBOX_MAILBOX_REG_TEST, MBLOGALL, 0);
679 for (i = 1; i < nmbox; i++) {
680 mbs.param[i] = patterns[i];
682 isp_mboxcmd(isp, &mbs);
683 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
686 for (i = 1; i < nmbox; i++) {
687 if (mbs.param[i] != patterns[i]) {
688 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]);
695 * Download new Firmware, unless requested not to do so.
696 * This is made slightly trickier in some cases where the
697 * firmware of the ROM revision is newer than the revision
698 * compiled into the driver. So, where we used to compare
699 * versions of our f/w and the ROM f/w, now we just see
700 * whether we have f/w at all and whether a config flag
701 * has disabled our download.
703 if ((isp->isp_mdvec->dv_ispfw == NULL) || (isp->isp_confopts & ISP_CFG_NORELOAD)) {
708 * Set up DMA for the request and response queues.
709 * We do this now so we can use the request queue
710 * for dma to load firmware from.
712 if (ISP_MBOXDMASETUP(isp) != 0) {
713 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
719 code_org = ISP_CODE_ORG_2400;
720 } else if (IS_23XX(isp)) {
721 code_org = ISP_CODE_ORG_2300;
723 code_org = ISP_CODE_ORG;
726 isp->isp_loaded_fw = 0;
727 if (dodnld && IS_24XX(isp)) {
728 const uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
732 * Keep loading until we run out of f/w.
734 code_org = ptr[2]; /* 1st load address is our start addr */
738 isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], ptr[2]);
743 while (wi < ptr[3]) {
747 nw = min(wl, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) / 4);
748 cp = isp->isp_rquest;
749 for (i = 0; i < nw; i++)
750 ISP_IOXPUT_32(isp, ptr[wi + i], &cp[i]);
751 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
752 MBSINIT(&mbs, MBOX_LOAD_RISC_RAM, MBLOGALL, 0);
754 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
755 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
756 mbs.param[4] = nw >> 16;
758 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
759 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
760 mbs.param[8] = la >> 16;
761 isp_prt(isp, ISP_LOGDEBUG0, "LOAD RISC RAM %u words at load address 0x%x", nw, la);
762 isp_mboxcmd(isp, &mbs);
763 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
764 isp_prt(isp, ISP_LOGERR, "F/W download failed");
777 isp->isp_loaded_fw = 1;
778 } else if (dodnld && IS_23XX(isp)) {
779 const uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
780 uint16_t wi, wl, segno;
789 isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], la);
794 while (wi < ptr[3]) {
798 nw = min(wl, min((1 << 15), ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) / 2));
799 cp = isp->isp_rquest;
800 for (i = 0; i < nw; i++)
801 ISP_IOXPUT_16(isp, ptr[wi + i], &cp[i]);
802 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
803 MBSINIT(&mbs, 0, MBLOGALL, 0);
805 mbs.param[0] = MBOX_LOAD_RISC_RAM_2100;
807 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
808 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
810 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
811 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
812 isp_prt(isp, ISP_LOGDEBUG1, "LOAD RISC RAM 2100 %u words at load address 0x%x\n", nw, la);
814 mbs.param[0] = MBOX_LOAD_RISC_RAM;
816 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
817 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
819 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
820 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
821 mbs.param[8] = la >> 16;
822 isp_prt(isp, ISP_LOGDEBUG1, "LOAD RISC RAM %u words at load address 0x%x\n", nw, la);
824 isp_mboxcmd(isp, &mbs);
825 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
826 isp_prt(isp, ISP_LOGERR, "F/W download failed");
843 * If we're a 2322, the firmware actually comes in
844 * three chunks. We loaded the first at the code_org
845 * address. The other two chunks, which follow right
846 * after each other in memory here, get loaded at
847 * addresses specfied at offset 0x9..0xB.
852 la = ptr[5] | ((ptr[4] & 0x3f) << 16);
854 isp->isp_loaded_fw = 1;
856 const uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
860 isp_prt(isp, ISP_LOGDEBUG1,
861 "WRITE RAM %u words at load address 0x%x", wl, code_org);
862 for (i = 0; i < wl; i++) {
863 MBSINIT(&mbs, MBOX_WRITE_RAM_WORD, MBLOGNONE, 0);
864 mbs.param[1] = code_org + i;
865 mbs.param[2] = ptr[i];
866 isp_mboxcmd(isp, &mbs);
867 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
868 isp_prt(isp, ISP_LOGERR,
869 "F/W download failed at word %d", i);
873 } else if (IS_26XX(isp)) {
874 MBSINIT(&mbs, MBOX_LOAD_FLASH_FIRMWARE, MBLOGALL, 5000000);
877 isp_mboxcmd(isp, &mbs);
878 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
879 isp_prt(isp, ISP_LOGERR, "Flash F/W load failed");
883 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
887 * If we loaded firmware, verify its checksum
889 if (isp->isp_loaded_fw) {
890 MBSINIT(&mbs, MBOX_VERIFY_CHECKSUM, MBLOGNONE, 0);
892 mbs.param[1] = code_org >> 16;
893 mbs.param[2] = code_org;
895 mbs.param[1] = code_org;
897 isp_mboxcmd(isp, &mbs);
898 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
899 isp_prt(isp, ISP_LOGERR, dcrc);
905 * Now start it rolling.
907 * If we didn't actually download f/w,
908 * we still need to (re)start it.
910 MBSINIT(&mbs, MBOX_EXEC_FIRMWARE, MBLOGALL, 5000000);
912 mbs.param[1] = code_org >> 16;
913 mbs.param[2] = code_org;
914 if (isp->isp_loaded_fw) {
919 } else if (IS_2322(isp)) {
920 mbs.param[1] = code_org;
921 if (isp->isp_loaded_fw) {
927 mbs.param[1] = code_org;
929 isp_mboxcmd(isp, &mbs);
930 if (IS_2322(isp) || IS_24XX(isp)) {
931 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
938 * Set CLOCK RATE, but only if asked to.
940 if (isp->isp_clock) {
941 MBSINIT(&mbs, MBOX_SET_CLOCK_RATE, MBLOGALL, 0);
942 mbs.param[1] = isp->isp_clock;
943 isp_mboxcmd(isp, &mbs);
944 /* we will try not to care if this fails */
949 * Ask the chip for the current firmware version.
950 * This should prove that the new firmware is working.
952 MBSINIT(&mbs, MBOX_ABOUT_FIRMWARE, MBLOGALL, 0);
953 isp_mboxcmd(isp, &mbs);
954 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
959 * The SBus firmware that we are using apparently does not return
960 * major, minor, micro revisions in the mailbox registers, which
961 * is really, really, annoying.
963 if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) {
965 #ifdef ISP_TARGET_MODE
966 isp->isp_fwrev[0] = 7;
967 isp->isp_fwrev[1] = 55;
969 isp->isp_fwrev[0] = 1;
970 isp->isp_fwrev[1] = 37;
972 isp->isp_fwrev[2] = 0;
975 isp->isp_fwrev[0] = mbs.param[1];
976 isp->isp_fwrev[1] = mbs.param[2];
977 isp->isp_fwrev[2] = mbs.param[3];
982 * We do not believe firmware attributes for 2100 code less
983 * than 1.17.0, unless it's the firmware we specifically
986 * Note that all 22XX and later f/w is greater than 1.X.0.
988 if ((ISP_FW_OLDER_THAN(isp, 1, 17, 1))) {
989 #ifdef USE_SMALLER_2100_FIRMWARE
990 isp->isp_fwattr = ISP_FW_ATTR_SCCLUN;
995 isp->isp_fwattr = mbs.param[6];
998 isp->isp_fwattr |= ((uint64_t) mbs.param[15]) << 16;
999 if (isp->isp_fwattr & ISP2400_FW_ATTR_EXTNDED) {
1001 (((uint64_t) mbs.param[16]) << 32) |
1002 (((uint64_t) mbs.param[17]) << 48);
1006 isp->isp_fwattr = 0;
1009 isp_prt(isp, ISP_LOGCONFIG, "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
1010 btype, isp->isp_revision, dodnld? "loaded" : "resident", isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
1012 fwt = isp->isp_fwattr;
1014 buf = FCPARAM(isp, 0)->isp_scanscratch;
1015 ISP_SNPRINTF(buf, ISP_FC_SCRLEN, "Attributes:");
1016 if (fwt & ISP2400_FW_ATTR_CLASS2) {
1017 fwt ^=ISP2400_FW_ATTR_CLASS2;
1018 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Class2", buf);
1020 if (fwt & ISP2400_FW_ATTR_IP) {
1021 fwt ^=ISP2400_FW_ATTR_IP;
1022 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s IP", buf);
1024 if (fwt & ISP2400_FW_ATTR_MULTIID) {
1025 fwt ^=ISP2400_FW_ATTR_MULTIID;
1026 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MultiID", buf);
1028 if (fwt & ISP2400_FW_ATTR_SB2) {
1029 fwt ^=ISP2400_FW_ATTR_SB2;
1030 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SB2", buf);
1032 if (fwt & ISP2400_FW_ATTR_T10CRC) {
1033 fwt ^=ISP2400_FW_ATTR_T10CRC;
1034 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s T10CRC", buf);
1036 if (fwt & ISP2400_FW_ATTR_VI) {
1037 fwt ^=ISP2400_FW_ATTR_VI;
1038 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI", buf);
1040 if (fwt & ISP2400_FW_ATTR_MQ) {
1041 fwt ^=ISP2400_FW_ATTR_MQ;
1042 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MQ", buf);
1044 if (fwt & ISP2400_FW_ATTR_MSIX) {
1045 fwt ^=ISP2400_FW_ATTR_MSIX;
1046 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MSIX", buf);
1048 if (fwt & ISP2400_FW_ATTR_FCOE) {
1049 fwt ^=ISP2400_FW_ATTR_FCOE;
1050 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s FCOE", buf);
1052 if (fwt & ISP2400_FW_ATTR_VP0) {
1053 fwt ^= ISP2400_FW_ATTR_VP0;
1054 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VP0_Decoupling", buf);
1056 if (fwt & ISP2400_FW_ATTR_EXPFW) {
1057 fwt ^= ISP2400_FW_ATTR_EXPFW;
1058 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (Experimental)", buf);
1060 if (fwt & ISP2400_FW_ATTR_HOTFW) {
1061 fwt ^= ISP2400_FW_ATTR_HOTFW;
1062 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s HotFW", buf);
1064 fwt &= ~ISP2400_FW_ATTR_EXTNDED;
1065 if (fwt & ISP2400_FW_ATTR_EXTVP) {
1066 fwt ^= ISP2400_FW_ATTR_EXTVP;
1067 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ExtVP", buf);
1069 if (fwt & ISP2400_FW_ATTR_VN2VN) {
1070 fwt ^= ISP2400_FW_ATTR_VN2VN;
1071 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VN2VN", buf);
1073 if (fwt & ISP2400_FW_ATTR_EXMOFF) {
1074 fwt ^= ISP2400_FW_ATTR_EXMOFF;
1075 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s EXMOFF", buf);
1077 if (fwt & ISP2400_FW_ATTR_NPMOFF) {
1078 fwt ^= ISP2400_FW_ATTR_NPMOFF;
1079 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s NPMOFF", buf);
1081 if (fwt & ISP2400_FW_ATTR_DIFCHOP) {
1082 fwt ^= ISP2400_FW_ATTR_DIFCHOP;
1083 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s DIFCHOP", buf);
1085 if (fwt & ISP2400_FW_ATTR_SRIOV) {
1086 fwt ^= ISP2400_FW_ATTR_SRIOV;
1087 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SRIOV", buf);
1089 if (fwt & ISP2400_FW_ATTR_ASICTMP) {
1090 fwt ^= ISP2400_FW_ATTR_ASICTMP;
1091 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ASICTMP", buf);
1093 if (fwt & ISP2400_FW_ATTR_ATIOMQ) {
1094 fwt ^= ISP2400_FW_ATTR_ATIOMQ;
1095 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ATIOMQ", buf);
1098 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (unknown 0x%08x%08x)", buf,
1099 (uint32_t) (fwt >> 32), (uint32_t) fwt);
1101 isp_prt(isp, ISP_LOGCONFIG, "%s", buf);
1102 } else if (IS_FC(isp)) {
1103 buf = FCPARAM(isp, 0)->isp_scanscratch;
1104 ISP_SNPRINTF(buf, ISP_FC_SCRLEN, "Attributes:");
1105 if (fwt & ISP_FW_ATTR_TMODE) {
1106 fwt ^=ISP_FW_ATTR_TMODE;
1107 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s TargetMode", buf);
1109 if (fwt & ISP_FW_ATTR_SCCLUN) {
1110 fwt ^=ISP_FW_ATTR_SCCLUN;
1111 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SCC-Lun", buf);
1113 if (fwt & ISP_FW_ATTR_FABRIC) {
1114 fwt ^=ISP_FW_ATTR_FABRIC;
1115 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Fabric", buf);
1117 if (fwt & ISP_FW_ATTR_CLASS2) {
1118 fwt ^=ISP_FW_ATTR_CLASS2;
1119 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Class2", buf);
1121 if (fwt & ISP_FW_ATTR_FCTAPE) {
1122 fwt ^=ISP_FW_ATTR_FCTAPE;
1123 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s FC-Tape", buf);
1125 if (fwt & ISP_FW_ATTR_IP) {
1126 fwt ^=ISP_FW_ATTR_IP;
1127 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s IP", buf);
1129 if (fwt & ISP_FW_ATTR_VI) {
1130 fwt ^=ISP_FW_ATTR_VI;
1131 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI", buf);
1133 if (fwt & ISP_FW_ATTR_VI_SOLARIS) {
1134 fwt ^=ISP_FW_ATTR_VI_SOLARIS;
1135 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI_SOLARIS", buf);
1137 if (fwt & ISP_FW_ATTR_2KLOGINS) {
1138 fwt ^=ISP_FW_ATTR_2KLOGINS;
1139 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s 2K-Login", buf);
1142 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (unknown 0x%08x%08x)", buf,
1143 (uint32_t) (fwt >> 32), (uint32_t) fwt);
1145 isp_prt(isp, ISP_LOGCONFIG, "%s", buf);
1149 MBSINIT(&mbs, MBOX_GET_RESOURCE_COUNT, MBLOGALL, 0);
1150 isp_mboxcmd(isp, &mbs);
1151 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1154 isp->isp_maxcmds = mbs.param[3];
1156 MBSINIT(&mbs, MBOX_GET_FIRMWARE_STATUS, MBLOGALL, 0);
1157 isp_mboxcmd(isp, &mbs);
1158 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1161 isp->isp_maxcmds = mbs.param[2];
1163 isp_prt(isp, ISP_LOGCONFIG, "%d max I/O command limit set", isp->isp_maxcmds);
1166 * If we don't have Multi-ID f/w loaded, we need to restrict channels to one.
1167 * Only make this check for non-SCSI cards (I'm not sure firmware attributes
1170 if (IS_FC(isp) && isp->isp_nchan > 1) {
1171 if (!ISP_CAP_MULTI_ID(isp)) {
1172 isp_prt(isp, ISP_LOGWARN, "non-MULTIID f/w loaded, "
1173 "only can enable 1 of %d channels", isp->isp_nchan);
1175 } else if (!ISP_CAP_VP0(isp)) {
1176 isp_prt(isp, ISP_LOGWARN, "We can not use MULTIID "
1177 "feature properly without VP0_Decoupling");
1183 * Final DMA setup after we got isp_maxcmds.
1185 if (ISP_MBOXDMASETUP(isp) != 0) {
1186 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
1193 if (ISP_IRQSETUP(isp) != 0) {
1194 isp_prt(isp, ISP_LOGERR, "Cannot setup IRQ");
1197 ISP_ENABLE_INTS(isp);
1200 for (i = 0; i < isp->isp_nchan; i++)
1201 isp_change_fw_state(isp, i, FW_CONFIG_WAIT);
1204 isp->isp_state = ISP_RESETSTATE;
1207 * Okay- now that we have new firmware running, we now (re)set our
1208 * notion of how many luns we support. This is somewhat tricky because
1209 * if we haven't loaded firmware, we sometimes do not have an easy way
1210 * of knowing how many luns we support.
1212 * Expanded lun firmware gives you 32 luns for SCSI cards and
1213 * unlimited luns for Fibre Channel cards.
1215 * It turns out that even for QLogic 2100s with ROM 1.10 and above
1216 * we do get a firmware attributes word returned in mailbox register 6.
1218 * Because the lun is in a different position in the Request Queue
1219 * Entry structure for Fibre Channel with expanded lun firmware, we
1220 * can only support one lun (lun zero) when we don't know what kind
1221 * of firmware we're running.
1225 if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
1226 isp->isp_maxluns = 32;
1228 isp->isp_maxluns = 8;
1231 isp->isp_maxluns = 8;
1234 if (ISP_CAP_SCCFW(isp)) {
1235 isp->isp_maxluns = 0; /* No limit -- 2/8 bytes */
1237 isp->isp_maxluns = 16;
1242 * We get some default values established. As a side
1243 * effect, NVRAM is read here (unless overriden by
1244 * a configuration flag).
1246 if (do_load_defaults) {
1248 isp_setdfltsdparm(isp);
1250 for (i = 0; i < isp->isp_nchan; i++) {
1251 isp_setdfltfcparm(isp, i);
1258 * Clean firmware shutdown.
1261 isp_stop(ispsoftc_t *isp)
1265 isp->isp_state = ISP_NILSTATE;
1266 MBSINIT(&mbs, MBOX_STOP_FIRMWARE, MBLOGALL, 500000);
1275 isp_mboxcmd(isp, &mbs);
1276 return (mbs.param[0] == MBOX_COMMAND_COMPLETE ? 0 : mbs.param[0]);
1280 * Hardware shutdown.
1283 isp_shutdown(ispsoftc_t *isp)
1286 if (isp->isp_state >= ISP_RESETSTATE)
1288 ISP_DISABLE_INTS(isp);
1291 ISP_WRITE(isp, BIU2400_ICR, 0);
1292 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
1294 ISP_WRITE(isp, BIU_ICR, 0);
1295 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
1296 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
1297 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
1298 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
1299 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
1300 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
1303 ISP_WRITE(isp, BIU_ICR, 0);
1304 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
1309 * Initialize Parameters of Hardware to a known state.
1311 * Locks are held before coming here.
1314 isp_init(ispsoftc_t *isp)
1318 isp_fibre_init_2400(isp);
1320 isp_fibre_init(isp);
1328 isp_scsi_init(ispsoftc_t *isp)
1330 sdparam *sdp_chan0, *sdp_chan1;
1333 isp->isp_state = ISP_INITSTATE;
1335 sdp_chan0 = SDPARAM(isp, 0);
1336 sdp_chan1 = sdp_chan0;
1337 if (IS_DUALBUS(isp)) {
1338 sdp_chan1 = SDPARAM(isp, 1);
1341 /* First do overall per-card settings. */
1344 * If we have fast memory timing enabled, turn it on.
1346 if (sdp_chan0->isp_fast_mttr) {
1347 ISP_WRITE(isp, RISC_MTR, 0x1313);
1351 * Set Retry Delay and Count.
1352 * You set both channels at the same time.
1354 MBSINIT(&mbs, MBOX_SET_RETRY_COUNT, MBLOGALL, 0);
1355 mbs.param[1] = sdp_chan0->isp_retry_count;
1356 mbs.param[2] = sdp_chan0->isp_retry_delay;
1357 mbs.param[6] = sdp_chan1->isp_retry_count;
1358 mbs.param[7] = sdp_chan1->isp_retry_delay;
1359 isp_mboxcmd(isp, &mbs);
1360 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1365 * Set ASYNC DATA SETUP time. This is very important.
1367 MBSINIT(&mbs, MBOX_SET_ASYNC_DATA_SETUP_TIME, MBLOGALL, 0);
1368 mbs.param[1] = sdp_chan0->isp_async_data_setup;
1369 mbs.param[2] = sdp_chan1->isp_async_data_setup;
1370 isp_mboxcmd(isp, &mbs);
1371 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1376 * Set ACTIVE Negation State.
1378 MBSINIT(&mbs, MBOX_SET_ACT_NEG_STATE, MBLOGNONE, 0);
1380 (sdp_chan0->isp_req_ack_active_neg << 4) |
1381 (sdp_chan0->isp_data_line_active_neg << 5);
1383 (sdp_chan1->isp_req_ack_active_neg << 4) |
1384 (sdp_chan1->isp_data_line_active_neg << 5);
1385 isp_mboxcmd(isp, &mbs);
1386 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1387 isp_prt(isp, ISP_LOGERR,
1388 "failed to set active negation state (%d,%d), (%d,%d)",
1389 sdp_chan0->isp_req_ack_active_neg,
1390 sdp_chan0->isp_data_line_active_neg,
1391 sdp_chan1->isp_req_ack_active_neg,
1392 sdp_chan1->isp_data_line_active_neg);
1399 * Set the Tag Aging limit
1401 MBSINIT(&mbs, MBOX_SET_TAG_AGE_LIMIT, MBLOGALL, 0);
1402 mbs.param[1] = sdp_chan0->isp_tag_aging;
1403 mbs.param[2] = sdp_chan1->isp_tag_aging;
1404 isp_mboxcmd(isp, &mbs);
1405 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1406 isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
1407 sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
1412 * Set selection timeout.
1414 MBSINIT(&mbs, MBOX_SET_SELECT_TIMEOUT, MBLOGALL, 0);
1415 mbs.param[1] = sdp_chan0->isp_selection_timeout;
1416 mbs.param[2] = sdp_chan1->isp_selection_timeout;
1417 isp_mboxcmd(isp, &mbs);
1418 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1422 /* now do per-channel settings */
1423 isp_scsi_channel_init(isp, 0);
1424 if (IS_DUALBUS(isp))
1425 isp_scsi_channel_init(isp, 1);
1428 * Now enable request/response queues
1431 if (IS_ULTRA2(isp) || IS_1240(isp)) {
1432 MBSINIT(&mbs, MBOX_INIT_RES_QUEUE_A64, MBLOGALL, 0);
1433 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1434 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1435 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1437 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1438 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1439 isp_mboxcmd(isp, &mbs);
1440 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1443 isp->isp_residx = isp->isp_resodx = mbs.param[5];
1445 MBSINIT(&mbs, MBOX_INIT_REQ_QUEUE_A64, MBLOGALL, 0);
1446 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1447 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1448 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1450 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1451 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1452 isp_mboxcmd(isp, &mbs);
1453 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1456 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1458 MBSINIT(&mbs, MBOX_INIT_RES_QUEUE, MBLOGALL, 0);
1459 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1460 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1461 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1463 isp_mboxcmd(isp, &mbs);
1464 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1467 isp->isp_residx = isp->isp_resodx = mbs.param[5];
1469 MBSINIT(&mbs, MBOX_INIT_REQ_QUEUE, MBLOGALL, 0);
1470 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1471 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1472 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1474 isp_mboxcmd(isp, &mbs);
1475 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1478 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1482 * Turn on LVD transitions for ULTRA2 or better and other features
1484 * Now that we have 32 bit handles, don't do any fast posting
1485 * any more. For Ultra2/Ultra3 cards, we can turn on 32 bit RIO
1486 * operation or use fast posting. To be conservative, we'll only
1487 * do this for Ultra3 cards now because the other cards are so
1488 * rare for this author to find and test with.
1491 MBSINIT(&mbs, MBOX_SET_FW_FEATURES, MBLOGALL, 0);
1493 mbs.param[1] |= FW_FEATURE_LVD_NOTIFY;
1496 mbs.param[1] |= FW_FEATURE_FAST_POST;
1499 mbs.param[1] |= FW_FEATURE_RIO_32BIT;
1501 if (mbs.param[1] != 0) {
1502 uint16_t sfeat = mbs.param[1];
1503 isp_mboxcmd(isp, &mbs);
1504 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1505 isp_prt(isp, ISP_LOGINFO,
1506 "Enabled FW features (0x%x)", sfeat);
1510 isp->isp_state = ISP_RUNSTATE;
1514 isp_scsi_channel_init(ispsoftc_t *isp, int chan)
1520 sdp = SDPARAM(isp, chan);
1523 * Set (possibly new) Initiator ID.
1525 MBSINIT(&mbs, MBOX_SET_INIT_SCSI_ID, MBLOGALL, 0);
1526 mbs.param[1] = (chan << 7) | sdp->isp_initiator_id;
1527 isp_mboxcmd(isp, &mbs);
1528 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1531 isp_prt(isp, ISP_LOGINFO, "Chan %d Initiator ID is %d",
1532 chan, sdp->isp_initiator_id);
1536 * Set current per-target parameters to an initial safe minimum.
1538 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1542 if (sdp->isp_devparam[tgt].dev_enable == 0) {
1545 #ifndef ISP_TARGET_MODE
1546 sdf = sdp->isp_devparam[tgt].goal_flags;
1547 sdf &= DPARM_SAFE_DFLT;
1549 * It is not quite clear when this changed over so that
1550 * we could force narrow and async for 1000/1020 cards,
1551 * but assume that this is only the case for loaded
1554 if (isp->isp_loaded_fw) {
1555 sdf |= DPARM_NARROW | DPARM_ASYNC;
1559 * The !$*!)$!$)* f/w uses the same index into some
1560 * internal table to decide how to respond to negotiations,
1561 * so if we've said "let's be safe" for ID X, and ID X
1562 * selects *us*, the negotiations will back to 'safe'
1563 * (as in narrow/async). What the f/w *should* do is
1564 * use the initiator id settings to decide how to respond.
1566 sdp->isp_devparam[tgt].goal_flags = sdf = DPARM_DEFAULT;
1568 MBSINIT(&mbs, MBOX_SET_TARGET_PARAMS, MBLOGNONE, 0);
1569 mbs.param[1] = (chan << 15) | (tgt << 8);
1571 if ((sdf & DPARM_SYNC) == 0) {
1575 (sdp->isp_devparam[tgt].goal_offset << 8) |
1576 (sdp->isp_devparam[tgt].goal_period);
1578 isp_prt(isp, ISP_LOGDEBUG0, "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
1579 chan, tgt, mbs.param[2], mbs.param[3] >> 8, mbs.param[3] & 0xff);
1580 isp_mboxcmd(isp, &mbs);
1581 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1582 sdf = DPARM_SAFE_DFLT;
1583 MBSINIT(&mbs, MBOX_SET_TARGET_PARAMS, MBLOGALL, 0);
1584 mbs.param[1] = (tgt << 8) | (chan << 15);
1587 isp_mboxcmd(isp, &mbs);
1588 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1594 * We don't update any information directly from the f/w
1595 * because we need to run at least one command to cause a
1596 * new state to be latched up. So, we just assume that we
1597 * converge to the values we just had set.
1599 * Ensure that we don't believe tagged queuing is enabled yet.
1600 * It turns out that sometimes the ISP just ignores our
1601 * attempts to set parameters for devices that it hasn't
1604 sdp->isp_devparam[tgt].actv_flags = sdf & ~DPARM_TQING;
1605 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1606 MBSINIT(&mbs, MBOX_SET_DEV_QUEUE_PARAMS, MBLOGALL, 0);
1607 mbs.param[1] = (chan << 15) | (tgt << 8) | lun;
1608 mbs.param[2] = sdp->isp_max_queue_depth;
1609 mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
1610 isp_mboxcmd(isp, &mbs);
1611 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1616 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1617 if (sdp->isp_devparam[tgt].dev_refresh) {
1618 sdp->sendmarker = 1;
1626 * Fibre Channel specific initialization.
1629 isp_fibre_init(ispsoftc_t *isp)
1632 isp_icb_t local, *icbp = &local;
1637 * We only support one channel on non-24XX cards
1639 fcp = FCPARAM(isp, 0);
1640 if (fcp->role == ISP_ROLE_NONE)
1643 isp->isp_state = ISP_INITSTATE;
1644 ISP_MEMZERO(icbp, sizeof (*icbp));
1645 icbp->icb_version = ICB_VERSION1;
1646 icbp->icb_fwoptions = fcp->isp_fwoptions;
1649 * Firmware Options are either retrieved from NVRAM or
1650 * are patched elsewhere. We check them for sanity here
1651 * and make changes based on board revision, but otherwise
1652 * let others decide policy.
1656 * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
1658 if (IS_2100(isp) && isp->isp_revision < 5) {
1659 icbp->icb_fwoptions &= ~ICBOPT_FAIRNESS;
1663 * We have to use FULL LOGIN even though it resets the loop too much
1664 * because otherwise port database entries don't get updated after
1665 * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
1667 if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1668 icbp->icb_fwoptions |= ICBOPT_FULL_LOGIN;
1672 * Insist on Port Database Update Async notifications
1674 icbp->icb_fwoptions |= ICBOPT_PDBCHANGE_AE;
1677 * Make sure that target role reflects into fwoptions.
1679 if (fcp->role & ISP_ROLE_TARGET) {
1680 icbp->icb_fwoptions |= ICBOPT_TGT_ENABLE;
1682 icbp->icb_fwoptions &= ~ICBOPT_TGT_ENABLE;
1686 * For some reason my 2200 does not generate ATIOs in target mode
1687 * if initiator is disabled. Extra logins are better then target
1688 * not working at all.
1690 if ((fcp->role & ISP_ROLE_INITIATOR) || IS_2100(isp) || IS_2200(isp)) {
1691 icbp->icb_fwoptions &= ~ICBOPT_INI_DISABLE;
1693 icbp->icb_fwoptions |= ICBOPT_INI_DISABLE;
1696 icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
1697 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1698 isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
1699 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1701 icbp->icb_maxalloc = fcp->isp_maxalloc;
1702 if (icbp->icb_maxalloc < 1) {
1703 isp_prt(isp, ISP_LOGERR, "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1704 icbp->icb_maxalloc = 16;
1706 icbp->icb_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
1707 if (icbp->icb_execthrottle < 1) {
1708 isp_prt(isp, ISP_LOGERR, "bad execution throttle of %d- using %d", DEFAULT_EXEC_THROTTLE(isp), ICB_DFLT_THROTTLE);
1709 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1711 icbp->icb_retry_delay = fcp->isp_retry_delay;
1712 icbp->icb_retry_count = fcp->isp_retry_count;
1713 icbp->icb_hardaddr = fcp->isp_loopid;
1714 ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
1715 if (icbp->icb_hardaddr >= LOCAL_LOOP_LIM) {
1716 icbp->icb_hardaddr = 0;
1721 * Our life seems so much better with 2200s and later with
1722 * the latest f/w if we set Hard Address.
1724 if (ownloopid || ISP_FW_NEWER_THAN(isp, 2, 2, 5)) {
1725 icbp->icb_fwoptions |= ICBOPT_HARD_ADDRESS;
1729 * Right now we just set extended options to prefer point-to-point
1730 * over loop based upon some soft config options.
1732 * NB: for the 2300, ICBOPT_EXTENDED is required.
1736 * We can't have Fast Posting any more- we now
1737 * have 32 bit handles.
1739 icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1740 } else if (IS_2200(isp) || IS_23XX(isp)) {
1741 icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1743 icbp->icb_xfwoptions = fcp->isp_xfwoptions;
1745 if (ISP_CAP_FCTAPE(isp)) {
1746 if (isp->isp_confopts & ISP_CFG_NOFCTAPE)
1747 icbp->icb_xfwoptions &= ~ICBXOPT_FCTAPE;
1749 if (isp->isp_confopts & ISP_CFG_FCTAPE)
1750 icbp->icb_xfwoptions |= ICBXOPT_FCTAPE;
1752 if (icbp->icb_xfwoptions & ICBXOPT_FCTAPE) {
1753 icbp->icb_fwoptions &= ~ICBOPT_FULL_LOGIN; /* per documents */
1754 icbp->icb_xfwoptions |= ICBXOPT_FCTAPE_CCQ|ICBXOPT_FCTAPE_CONFIRM;
1755 FCPARAM(isp, 0)->fctape_enabled = 1;
1757 FCPARAM(isp, 0)->fctape_enabled = 0;
1760 icbp->icb_xfwoptions &= ~ICBXOPT_FCTAPE;
1761 FCPARAM(isp, 0)->fctape_enabled = 0;
1765 * Prefer or force Point-To-Point instead Loop?
1767 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
1768 case ISP_CFG_LPORT_ONLY:
1769 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1770 icbp->icb_xfwoptions |= ICBXOPT_LOOP_ONLY;
1772 case ISP_CFG_NPORT_ONLY:
1773 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1774 icbp->icb_xfwoptions |= ICBXOPT_PTP_ONLY;
1777 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1778 icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1781 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1782 icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
1785 /* Let NVRAM settings define it if they are sane */
1786 switch (icbp->icb_xfwoptions & ICBXOPT_TOPO_MASK) {
1787 case ICBXOPT_PTP_2_LOOP:
1788 case ICBXOPT_PTP_ONLY:
1789 case ICBXOPT_LOOP_ONLY:
1790 case ICBXOPT_LOOP_2_PTP:
1793 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1794 icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1800 * We can't have Fast Posting any more- we now
1801 * have 32 bit handles.
1803 * RIO seemed to have to much breakage.
1805 * Just opt for safety.
1807 icbp->icb_xfwoptions &= ~ICBXOPT_RIO_16BIT;
1808 icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1811 * QLogic recommends that FAST Posting be turned
1812 * off for 23XX cards and instead allow the HBA
1813 * to write response queue entries and interrupt
1814 * after a delay (ZIO).
1816 icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1817 if ((fcp->isp_xfwoptions & ICBXOPT_TIMER_MASK) == ICBXOPT_ZIO) {
1818 icbp->icb_xfwoptions |= ICBXOPT_ZIO;
1819 icbp->icb_idelaytimer = 10;
1821 icbp->icb_zfwoptions = fcp->isp_zfwoptions;
1822 if (isp->isp_confopts & ISP_CFG_1GB) {
1823 icbp->icb_zfwoptions &= ~ICBZOPT_RATE_MASK;
1824 icbp->icb_zfwoptions |= ICBZOPT_RATE_1GB;
1825 } else if (isp->isp_confopts & ISP_CFG_2GB) {
1826 icbp->icb_zfwoptions &= ~ICBZOPT_RATE_MASK;
1827 icbp->icb_zfwoptions |= ICBZOPT_RATE_2GB;
1829 switch (icbp->icb_zfwoptions & ICBZOPT_RATE_MASK) {
1830 case ICBZOPT_RATE_1GB:
1831 case ICBZOPT_RATE_2GB:
1832 case ICBZOPT_RATE_AUTO:
1835 icbp->icb_zfwoptions &= ~ICBZOPT_RATE_MASK;
1836 icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO;
1845 * For 22XX > 2.1.26 && 23XX, set some options.
1847 if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1848 MBSINIT(&mbs, MBOX_SET_FIRMWARE_OPTIONS, MBLOGALL, 0);
1849 mbs.param[1] = IFCOPT1_DISF7SWTCH|IFCOPT1_LIPASYNC|IFCOPT1_LIPF8;
1852 if (ISP_FW_NEWER_THAN(isp, 3, 16, 0)) {
1853 mbs.param[1] |= IFCOPT1_EQFQASYNC|IFCOPT1_CTIO_RETRY;
1854 if (fcp->role & ISP_ROLE_TARGET) {
1855 if (ISP_FW_NEWER_THAN(isp, 3, 25, 0)) {
1856 mbs.param[1] |= IFCOPT1_ENAPURE;
1858 mbs.param[3] = IFCOPT3_NOPRLI;
1861 isp_mboxcmd(isp, &mbs);
1862 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1866 icbp->icb_logintime = ICB_LOGIN_TOV;
1868 #ifdef ISP_TARGET_MODE
1869 if (icbp->icb_fwoptions & ICBOPT_TGT_ENABLE) {
1870 icbp->icb_lunenables = 0xffff;
1871 icbp->icb_ccnt = 0xff;
1872 icbp->icb_icnt = 0xff;
1873 icbp->icb_lunetimeout = ICB_LUN_ENABLE_TOV;
1876 if (fcp->isp_wwnn && fcp->isp_wwpn) {
1877 icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
1878 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwnn);
1879 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
1880 isp_prt(isp, ISP_LOGDEBUG1,
1881 "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1882 ((uint32_t) (fcp->isp_wwnn >> 32)),
1883 ((uint32_t) (fcp->isp_wwnn)),
1884 ((uint32_t) (fcp->isp_wwpn >> 32)),
1885 ((uint32_t) (fcp->isp_wwpn)));
1886 } else if (fcp->isp_wwpn) {
1887 icbp->icb_fwoptions &= ~ICBOPT_BOTH_WWNS;
1888 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
1889 isp_prt(isp, ISP_LOGDEBUG1,
1890 "Setting ICB Port 0x%08x%08x",
1891 ((uint32_t) (fcp->isp_wwpn >> 32)),
1892 ((uint32_t) (fcp->isp_wwpn)));
1894 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1897 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1898 if (icbp->icb_rqstqlen < 1) {
1899 isp_prt(isp, ISP_LOGERR, "bad request queue length");
1901 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1902 if (icbp->icb_rsltqlen < 1) {
1903 isp_prt(isp, ISP_LOGERR, "bad result queue length");
1905 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1906 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1907 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1908 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1909 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1910 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1911 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1912 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1914 if (FC_SCRATCH_ACQUIRE(isp, 0)) {
1915 isp_prt(isp, ISP_LOGERR, sacq);
1918 isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
1919 icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions);
1921 isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
1922 if (isp->isp_dblev & ISP_LOGDEBUG1) {
1923 isp_print_bytes(isp, "isp_fibre_init",
1924 sizeof(*icbp), fcp->isp_scratch);
1930 MBSINIT(&mbs, MBOX_INIT_FIRMWARE, MBLOGALL, 30000000);
1932 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1933 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1934 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1935 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1936 isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %p (%08x%08x)",
1937 fcp->isp_scratch, (uint32_t) ((uint64_t)fcp->isp_scdma >> 32),
1938 (uint32_t) fcp->isp_scdma);
1939 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
1940 isp_mboxcmd(isp, &mbs);
1941 FC_SCRATCH_RELEASE(isp, 0);
1942 if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
1944 isp->isp_reqidx = 0;
1945 isp->isp_reqodx = 0;
1946 isp->isp_residx = 0;
1947 isp->isp_resodx = 0;
1950 * Whatever happens, we're now committed to being here.
1952 isp->isp_state = ISP_RUNSTATE;
1956 isp_fibre_init_2400(ispsoftc_t *isp)
1959 isp_icb_2400_t local, *icbp = &local;
1965 * Check to see whether all channels have *some* kind of role
1967 for (chan = 0; chan < isp->isp_nchan; chan++) {
1968 fcp = FCPARAM(isp, chan);
1969 if (fcp->role != ISP_ROLE_NONE) {
1973 if (chan == isp->isp_nchan) {
1974 isp_prt(isp, ISP_LOG_WARN1, "all %d channels with role 'none'", chan);
1978 isp->isp_state = ISP_INITSTATE;
1981 * Start with channel 0.
1983 fcp = FCPARAM(isp, 0);
1986 * Turn on LIP F8 async event (1)
1988 MBSINIT(&mbs, MBOX_SET_FIRMWARE_OPTIONS, MBLOGALL, 0);
1990 isp_mboxcmd(isp, &mbs);
1991 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1995 ISP_MEMZERO(icbp, sizeof (*icbp));
1996 icbp->icb_fwoptions1 = fcp->isp_fwoptions;
1997 icbp->icb_fwoptions2 = fcp->isp_xfwoptions;
1998 icbp->icb_fwoptions3 = fcp->isp_zfwoptions;
1999 if (isp->isp_nchan > 1 && ISP_CAP_VP0(isp)) {
2000 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_INI_DISABLE;
2001 icbp->icb_fwoptions1 |= ICB2400_OPT1_TGT_ENABLE;
2003 if (fcp->role & ISP_ROLE_TARGET)
2004 icbp->icb_fwoptions1 |= ICB2400_OPT1_TGT_ENABLE;
2006 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_TGT_ENABLE;
2007 if (fcp->role & ISP_ROLE_INITIATOR)
2008 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_INI_DISABLE;
2010 icbp->icb_fwoptions1 |= ICB2400_OPT1_INI_DISABLE;
2013 icbp->icb_version = ICB_VERSION1;
2014 icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
2015 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
2016 isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
2017 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
2020 icbp->icb_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
2021 if (icbp->icb_execthrottle < 1) {
2022 isp_prt(isp, ISP_LOGERR, "bad execution throttle of %d- using %d", DEFAULT_EXEC_THROTTLE(isp), ICB_DFLT_THROTTLE);
2023 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
2027 * Set target exchange count. Take half if we are supporting both roles.
2029 if (icbp->icb_fwoptions1 & ICB2400_OPT1_TGT_ENABLE) {
2030 icbp->icb_xchgcnt = isp->isp_maxcmds;
2031 if ((icbp->icb_fwoptions1 & ICB2400_OPT1_INI_DISABLE) == 0)
2032 icbp->icb_xchgcnt >>= 1;
2036 ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
2037 icbp->icb_hardaddr = fcp->isp_loopid;
2038 if (icbp->icb_hardaddr >= LOCAL_LOOP_LIM) {
2039 icbp->icb_hardaddr = 0;
2044 icbp->icb_fwoptions1 |= ICB2400_OPT1_HARD_ADDRESS;
2046 if (isp->isp_confopts & ISP_CFG_NOFCTAPE) {
2047 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_FCTAPE;
2049 if (isp->isp_confopts & ISP_CFG_FCTAPE) {
2050 icbp->icb_fwoptions2 |= ICB2400_OPT2_FCTAPE;
2053 for (chan = 0; chan < isp->isp_nchan; chan++) {
2054 if (icbp->icb_fwoptions2 & ICB2400_OPT2_FCTAPE)
2055 FCPARAM(isp, chan)->fctape_enabled = 1;
2057 FCPARAM(isp, chan)->fctape_enabled = 0;
2060 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
2061 case ISP_CFG_LPORT_ONLY:
2062 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2063 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_ONLY;
2065 case ISP_CFG_NPORT_ONLY:
2066 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2067 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_ONLY;
2070 /* ISP_CFG_PTP_2_LOOP not available in 24XX/25XX */
2072 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2073 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
2076 /* Let NVRAM settings define it if they are sane */
2077 switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TOPO_MASK) {
2078 case ICB2400_OPT2_LOOP_ONLY:
2079 case ICB2400_OPT2_PTP_ONLY:
2080 case ICB2400_OPT2_LOOP_2_PTP:
2083 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2084 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
2089 switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK) {
2090 case ICB2400_OPT2_ZIO:
2091 case ICB2400_OPT2_ZIO1:
2092 icbp->icb_idelaytimer = 0;
2097 isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field", icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
2098 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TIMER_MASK;
2103 /* Use handshake to reduce global lock congestion. */
2104 icbp->icb_fwoptions2 |= ICB2400_OPT2_ENA_IHR;
2105 icbp->icb_fwoptions2 |= ICB2400_OPT2_ENA_IHA;
2108 if ((icbp->icb_fwoptions3 & ICB2400_OPT3_RSPSZ_MASK) == 0) {
2109 icbp->icb_fwoptions3 |= ICB2400_OPT3_RSPSZ_24;
2111 if (isp->isp_confopts & ISP_CFG_1GB) {
2112 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2113 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_1GB;
2114 } else if (isp->isp_confopts & ISP_CFG_2GB) {
2115 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2116 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_2GB;
2117 } else if (isp->isp_confopts & ISP_CFG_4GB) {
2118 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2119 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_4GB;
2120 } else if (isp->isp_confopts & ISP_CFG_8GB) {
2121 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2122 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_8GB;
2123 } else if (isp->isp_confopts & ISP_CFG_16GB) {
2124 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2125 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_16GB;
2127 switch (icbp->icb_fwoptions3 & ICB2400_OPT3_RATE_MASK) {
2128 case ICB2400_OPT3_RATE_4GB:
2129 case ICB2400_OPT3_RATE_8GB:
2130 case ICB2400_OPT3_RATE_16GB:
2131 case ICB2400_OPT3_RATE_AUTO:
2133 case ICB2400_OPT3_RATE_2GB:
2134 if (isp->isp_type <= ISP_HA_FC_2500)
2137 case ICB2400_OPT3_RATE_1GB:
2138 if (isp->isp_type <= ISP_HA_FC_2400)
2142 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2143 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_AUTO;
2147 if (ownloopid == 0) {
2148 icbp->icb_fwoptions3 |= ICB2400_OPT3_SOFTID;
2150 icbp->icb_logintime = ICB_LOGIN_TOV;
2152 if (fcp->isp_wwnn && fcp->isp_wwpn) {
2153 icbp->icb_fwoptions1 |= ICB2400_OPT1_BOTH_WWNS;
2154 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
2155 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwnn);
2156 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)),
2157 ((uint32_t) (fcp->isp_wwpn >> 32)), ((uint32_t) (fcp->isp_wwpn)));
2158 } else if (fcp->isp_wwpn) {
2159 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_BOTH_WWNS;
2160 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
2161 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)));
2163 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
2166 icbp->icb_retry_count = fcp->isp_retry_count;
2168 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
2169 if (icbp->icb_rqstqlen < 8) {
2170 isp_prt(isp, ISP_LOGERR, "bad request queue length %d", icbp->icb_rqstqlen);
2173 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
2174 if (icbp->icb_rsltqlen < 8) {
2175 isp_prt(isp, ISP_LOGERR, "bad result queue length %d",
2176 icbp->icb_rsltqlen);
2179 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
2180 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
2181 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
2182 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
2184 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
2185 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
2186 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
2187 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
2189 #ifdef ISP_TARGET_MODE
2190 /* unconditionally set up the ATIO queue if we support target mode */
2191 icbp->icb_atioqlen = RESULT_QUEUE_LEN(isp);
2192 if (icbp->icb_atioqlen < 8) {
2193 isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d", icbp->icb_atioqlen);
2196 icbp->icb_atioqaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_atioq_dma);
2197 icbp->icb_atioqaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_atioq_dma);
2198 icbp->icb_atioqaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_atioq_dma);
2199 icbp->icb_atioqaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_atioq_dma);
2200 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),
2201 DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
2204 if (ISP_CAP_MSIX(isp) && isp->isp_nirq >= 2) {
2205 icbp->icb_msixresp = 1;
2206 if (IS_26XX(isp) && isp->isp_nirq >= 3)
2207 icbp->icb_msixatio = 2;
2210 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);
2212 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),
2213 DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma), DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
2214 DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
2216 if (FC_SCRATCH_ACQUIRE(isp, 0)) {
2217 isp_prt(isp, ISP_LOGERR, sacq);
2220 ISP_MEMZERO(fcp->isp_scratch, ISP_FC_SCRLEN);
2221 isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
2222 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2223 isp_print_bytes(isp, "isp_fibre_init_2400",
2224 sizeof (*icbp), fcp->isp_scratch);
2228 * Now fill in information about any additional channels
2230 if (isp->isp_nchan > 1) {
2231 isp_icb_2400_vpinfo_t vpinfo, *vdst;
2232 vp_port_info_t pi, *pdst;
2236 vpinfo.vp_global_options = ICB2400_VPGOPT_GEN_RIDA;
2237 if (ISP_CAP_VP0(isp)) {
2238 vpinfo.vp_global_options |= ICB2400_VPGOPT_VP0_DECOUPLE;
2239 vpinfo.vp_count = isp->isp_nchan;
2242 vpinfo.vp_count = isp->isp_nchan - 1;
2245 off = fcp->isp_scratch;
2246 off += ICB2400_VPINFO_OFF;
2247 vdst = (isp_icb_2400_vpinfo_t *) off;
2248 isp_put_icb_2400_vpinfo(isp, &vpinfo, vdst);
2249 amt = ICB2400_VPINFO_OFF + sizeof (isp_icb_2400_vpinfo_t);
2250 for (; chan < isp->isp_nchan; chan++) {
2253 ISP_MEMZERO(&pi, sizeof (pi));
2254 fcp2 = FCPARAM(isp, chan);
2255 if (fcp2->role != ISP_ROLE_NONE) {
2256 pi.vp_port_options = ICB2400_VPOPT_ENABLED |
2257 ICB2400_VPOPT_ENA_SNSLOGIN;
2258 if (fcp2->role & ISP_ROLE_INITIATOR)
2259 pi.vp_port_options |= ICB2400_VPOPT_INI_ENABLE;
2260 if ((fcp2->role & ISP_ROLE_TARGET) == 0)
2261 pi.vp_port_options |= ICB2400_VPOPT_TGT_DISABLE;
2262 if (fcp2->isp_loopid < LOCAL_LOOP_LIM) {
2263 pi.vp_port_loopid = fcp2->isp_loopid;
2264 if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
2265 pi.vp_port_options |= ICB2400_VPOPT_HARD_ADDRESS;
2269 MAKE_NODE_NAME_FROM_WWN(pi.vp_port_portname, fcp2->isp_wwpn);
2270 MAKE_NODE_NAME_FROM_WWN(pi.vp_port_nodename, fcp2->isp_wwnn);
2271 off = fcp->isp_scratch;
2272 if (ISP_CAP_VP0(isp))
2273 off += ICB2400_VPINFO_PORT_OFF(chan);
2275 off += ICB2400_VPINFO_PORT_OFF(chan - 1);
2276 pdst = (vp_port_info_t *) off;
2277 isp_put_vp_port_info(isp, &pi, pdst);
2278 amt += ICB2400_VPOPT_WRITE_SIZE;
2280 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2281 isp_print_bytes(isp, "isp_fibre_init_2400",
2282 amt - ICB2400_VPINFO_OFF,
2283 (char *)fcp->isp_scratch + ICB2400_VPINFO_OFF);
2290 MBSINIT(&mbs, 0, MBLOGALL, 30000000);
2291 if (isp->isp_nchan > 1) {
2292 mbs.param[0] = MBOX_INIT_FIRMWARE_MULTI_ID;
2294 mbs.param[0] = MBOX_INIT_FIRMWARE;
2297 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2298 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2299 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2300 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2301 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));
2302 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
2303 isp_mboxcmd(isp, &mbs);
2304 FC_SCRATCH_RELEASE(isp, 0);
2306 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2309 isp->isp_reqidx = 0;
2310 isp->isp_reqodx = 0;
2311 isp->isp_residx = 0;
2312 isp->isp_resodx = 0;
2313 isp->isp_atioodx = 0;
2316 * Whatever happens, we're now committed to being here.
2318 isp->isp_state = ISP_RUNSTATE;
2322 isp_fc_enable_vp(ispsoftc_t *isp, int chan)
2324 fcparam *fcp = FCPARAM(isp, chan);
2327 uint8_t resp[QENTRY_LEN];
2329 /* Build a VP MODIFY command in memory */
2330 ISP_MEMZERO(&vp, sizeof(vp));
2331 vp.vp_mod_hdr.rqs_entry_type = RQSTYPE_VP_MODIFY;
2332 vp.vp_mod_hdr.rqs_entry_count = 1;
2334 vp.vp_mod_idx0 = chan;
2335 vp.vp_mod_cmd = VP_MODIFY_ENA;
2336 vp.vp_mod_ports[0].options = ICB2400_VPOPT_ENABLED |
2337 ICB2400_VPOPT_ENA_SNSLOGIN;
2338 if (fcp->role & ISP_ROLE_INITIATOR)
2339 vp.vp_mod_ports[0].options |= ICB2400_VPOPT_INI_ENABLE;
2340 if ((fcp->role & ISP_ROLE_TARGET) == 0)
2341 vp.vp_mod_ports[0].options |= ICB2400_VPOPT_TGT_DISABLE;
2342 if (fcp->isp_loopid < LOCAL_LOOP_LIM) {
2343 vp.vp_mod_ports[0].loopid = fcp->isp_loopid;
2344 if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
2345 vp.vp_mod_ports[0].options |= ICB2400_VPOPT_HARD_ADDRESS;
2347 MAKE_NODE_NAME_FROM_WWN(vp.vp_mod_ports[0].wwpn, fcp->isp_wwpn);
2348 MAKE_NODE_NAME_FROM_WWN(vp.vp_mod_ports[0].wwnn, fcp->isp_wwnn);
2350 /* Prepare space for response in memory */
2351 memset(resp, 0xff, sizeof(resp));
2352 vp.vp_mod_hdl = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2353 if (vp.vp_mod_hdl == 0) {
2354 isp_prt(isp, ISP_LOGERR,
2355 "%s: VP_MODIFY of Chan %d out of handles", __func__, chan);
2359 /* Send request and wait for response. */
2360 reqp = isp_getrqentry(isp);
2362 isp_prt(isp, ISP_LOGERR,
2363 "%s: VP_MODIFY of Chan %d out of rqent", __func__, chan);
2364 isp_destroy_handle(isp, vp.vp_mod_hdl);
2367 isp_put_vp_modify(isp, &vp, (vp_modify_t *)reqp);
2368 if (isp->isp_dblev & ISP_LOGDEBUG1)
2369 isp_print_bytes(isp, "IOCB VP_MODIFY", QENTRY_LEN, reqp);
2370 ISP_SYNC_REQUEST(isp);
2371 if (msleep(resp, &isp->isp_lock, 0, "VP_MODIFY", 5*hz) == EWOULDBLOCK) {
2372 isp_prt(isp, ISP_LOGERR,
2373 "%s: VP_MODIFY of Chan %d timed out", __func__, chan);
2374 isp_destroy_handle(isp, vp.vp_mod_hdl);
2377 if (isp->isp_dblev & ISP_LOGDEBUG1)
2378 isp_print_bytes(isp, "IOCB VP_MODIFY response", QENTRY_LEN, resp);
2379 isp_get_vp_modify(isp, (vp_modify_t *)resp, &vp);
2381 if (vp.vp_mod_hdr.rqs_flags != 0 || vp.vp_mod_status != VP_STS_OK) {
2382 isp_prt(isp, ISP_LOGERR,
2383 "%s: VP_MODIFY of Chan %d failed with flags %x status %d",
2384 __func__, chan, vp.vp_mod_hdr.rqs_flags, vp.vp_mod_status);
2391 isp_fc_disable_vp(ispsoftc_t *isp, int chan)
2395 uint8_t resp[QENTRY_LEN];
2397 /* Build a VP CTRL command in memory */
2398 ISP_MEMZERO(&vp, sizeof(vp));
2399 vp.vp_ctrl_hdr.rqs_entry_type = RQSTYPE_VP_CTRL;
2400 vp.vp_ctrl_hdr.rqs_entry_count = 1;
2401 if (ISP_CAP_VP0(isp)) {
2402 vp.vp_ctrl_status = 1;
2404 vp.vp_ctrl_status = 0;
2405 chan--; /* VP0 can not be controlled in this case. */
2407 vp.vp_ctrl_command = VP_CTRL_CMD_DISABLE_VP_LOGO_ALL;
2408 vp.vp_ctrl_vp_count = 1;
2409 vp.vp_ctrl_idmap[chan / 16] |= (1 << chan % 16);
2411 /* Prepare space for response in memory */
2412 memset(resp, 0xff, sizeof(resp));
2413 vp.vp_ctrl_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2414 if (vp.vp_ctrl_handle == 0) {
2415 isp_prt(isp, ISP_LOGERR,
2416 "%s: VP_CTRL of Chan %d out of handles", __func__, chan);
2420 /* Send request and wait for response. */
2421 reqp = isp_getrqentry(isp);
2423 isp_prt(isp, ISP_LOGERR,
2424 "%s: VP_CTRL of Chan %d out of rqent", __func__, chan);
2425 isp_destroy_handle(isp, vp.vp_ctrl_handle);
2428 isp_put_vp_ctrl_info(isp, &vp, (vp_ctrl_info_t *)reqp);
2429 if (isp->isp_dblev & ISP_LOGDEBUG1)
2430 isp_print_bytes(isp, "IOCB VP_CTRL", QENTRY_LEN, reqp);
2431 ISP_SYNC_REQUEST(isp);
2432 if (msleep(resp, &isp->isp_lock, 0, "VP_CTRL", 5*hz) == EWOULDBLOCK) {
2433 isp_prt(isp, ISP_LOGERR,
2434 "%s: VP_CTRL of Chan %d timed out", __func__, chan);
2435 isp_destroy_handle(isp, vp.vp_ctrl_handle);
2438 if (isp->isp_dblev & ISP_LOGDEBUG1)
2439 isp_print_bytes(isp, "IOCB VP_CTRL response", QENTRY_LEN, resp);
2440 isp_get_vp_ctrl_info(isp, (vp_ctrl_info_t *)resp, &vp);
2442 if (vp.vp_ctrl_hdr.rqs_flags != 0 || vp.vp_ctrl_status != 0) {
2443 isp_prt(isp, ISP_LOGERR,
2444 "%s: VP_CTRL of Chan %d failed with flags %x status %d %d",
2445 __func__, chan, vp.vp_ctrl_hdr.rqs_flags,
2446 vp.vp_ctrl_status, vp.vp_ctrl_index_fail);
2453 isp_fc_change_role(ispsoftc_t *isp, int chan, int new_role)
2455 fcparam *fcp = FCPARAM(isp, chan);
2456 int i, was, res = 0;
2458 if (chan >= isp->isp_nchan) {
2459 isp_prt(isp, ISP_LOGWARN, "%s: bad channel %d", __func__, chan);
2462 if (fcp->role == new_role)
2464 for (was = 0, i = 0; i < isp->isp_nchan; i++) {
2465 if (FCPARAM(isp, i)->role != ISP_ROLE_NONE)
2468 if (was == 0 || (was == 1 && fcp->role != ISP_ROLE_NONE)) {
2469 fcp->role = new_role;
2470 return (isp_reinit(isp, 0));
2472 if (fcp->role != ISP_ROLE_NONE) {
2473 res = isp_fc_disable_vp(isp, chan);
2474 isp_clear_portdb(isp, chan);
2476 fcp->role = new_role;
2477 if (fcp->role != ISP_ROLE_NONE)
2478 res = isp_fc_enable_vp(isp, chan);
2483 isp_clear_portdb(ispsoftc_t *isp, int chan)
2485 fcparam *fcp = FCPARAM(isp, chan);
2489 for (i = 0; i < MAX_FC_TARG; i++) {
2490 lp = &fcp->portdb[i];
2491 switch (lp->state) {
2492 case FC_PORTDB_STATE_DEAD:
2493 case FC_PORTDB_STATE_CHANGED:
2494 case FC_PORTDB_STATE_VALID:
2495 lp->state = FC_PORTDB_STATE_NIL;
2496 isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
2498 case FC_PORTDB_STATE_NIL:
2499 case FC_PORTDB_STATE_NEW:
2500 lp->state = FC_PORTDB_STATE_NIL;
2502 case FC_PORTDB_STATE_ZOMBIE:
2505 panic("Don't know how to clear state %d\n", lp->state);
2511 isp_mark_portdb(ispsoftc_t *isp, int chan)
2513 fcparam *fcp = FCPARAM(isp, chan);
2517 for (i = 0; i < MAX_FC_TARG; i++) {
2518 lp = &fcp->portdb[i];
2519 if (lp->state == FC_PORTDB_STATE_NIL)
2521 if (lp->portid >= DOMAIN_CONTROLLER_BASE &&
2522 lp->portid <= DOMAIN_CONTROLLER_END)
2524 fcp->portdb[i].probational = 1;
2529 * Perform an IOCB PLOGI or LOGO via EXECUTE IOCB A64 for 24XX cards
2530 * or via FABRIC LOGIN/FABRIC LOGOUT for other cards.
2533 isp_plogx(ispsoftc_t *isp, int chan, uint16_t handle, uint32_t portid, int flags)
2537 uint8_t resp[QENTRY_LEN];
2538 uint32_t sst, parm1;
2543 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d PLOGX %s PortID 0x%06x nphdl 0x%x",
2544 chan, (flags & PLOGX_FLG_CMD_MASK) == PLOGX_FLG_CMD_PLOGI ?
2545 "Login":"Logout", portid, handle);
2546 if (!IS_24XX(isp)) {
2547 int action = flags & PLOGX_FLG_CMD_MASK;
2548 if (action == PLOGX_FLG_CMD_PLOGI) {
2549 return (isp_port_login(isp, handle, portid));
2550 } else if (action == PLOGX_FLG_CMD_LOGO) {
2551 return (isp_port_logout(isp, handle, portid));
2553 return (MBOX_INVALID_COMMAND);
2557 ISP_MEMZERO(&pl, sizeof(pl));
2558 pl.plogx_header.rqs_entry_count = 1;
2559 pl.plogx_header.rqs_entry_type = RQSTYPE_LOGIN;
2560 pl.plogx_nphdl = handle;
2561 pl.plogx_vphdl = chan;
2562 pl.plogx_portlo = portid;
2563 pl.plogx_rspsz_porthi = (portid >> 16) & 0xff;
2564 pl.plogx_flags = flags;
2566 /* Prepare space for response in memory */
2567 memset(resp, 0xff, sizeof(resp));
2568 pl.plogx_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2569 if (pl.plogx_handle == 0) {
2570 isp_prt(isp, ISP_LOGERR,
2571 "%s: PLOGX of Chan %d out of handles", __func__, chan);
2575 /* Send request and wait for response. */
2576 reqp = isp_getrqentry(isp);
2578 isp_prt(isp, ISP_LOGERR,
2579 "%s: PLOGX of Chan %d out of rqent", __func__, chan);
2580 isp_destroy_handle(isp, pl.plogx_handle);
2583 isp_put_plogx(isp, &pl, (isp_plogx_t *)reqp);
2584 if (isp->isp_dblev & ISP_LOGDEBUG1)
2585 isp_print_bytes(isp, "IOCB LOGX", QENTRY_LEN, reqp);
2586 FCPARAM(isp, chan)->isp_login_hdl = handle;
2587 ISP_SYNC_REQUEST(isp);
2588 if (msleep(resp, &isp->isp_lock, 0, "PLOGX", 3 * ICB_LOGIN_TOV * hz)
2590 isp_prt(isp, ISP_LOGERR,
2591 "%s: PLOGX of Chan %d timed out", __func__, chan);
2592 isp_destroy_handle(isp, pl.plogx_handle);
2595 FCPARAM(isp, chan)->isp_login_hdl = NIL_HANDLE;
2596 if (isp->isp_dblev & ISP_LOGDEBUG1)
2597 isp_print_bytes(isp, "IOCB LOGX response", QENTRY_LEN, resp);
2598 isp_get_plogx(isp, (isp_plogx_t *)resp, &pl);
2600 if (pl.plogx_status == PLOGX_STATUS_OK) {
2602 } else if (pl.plogx_status != PLOGX_STATUS_IOCBERR) {
2603 isp_prt(isp, ISP_LOGWARN,
2604 "status 0x%x on port login IOCB channel %d",
2605 pl.plogx_status, chan);
2609 sst = pl.plogx_ioparm[0].lo16 | (pl.plogx_ioparm[0].hi16 << 16);
2610 parm1 = pl.plogx_ioparm[1].lo16 | (pl.plogx_ioparm[1].hi16 << 16);
2617 case PLOGX_IOCBERR_NOLINK:
2620 case PLOGX_IOCBERR_NOIOCB:
2621 msg = "no IOCB buffer";
2623 case PLOGX_IOCBERR_NOXGHG:
2624 msg = "no Exchange Control Block";
2626 case PLOGX_IOCBERR_FAILED:
2627 ISP_SNPRINTF(buf, sizeof (buf), "reason 0x%x (last LOGIN state 0x%x)", parm1 & 0xff, (parm1 >> 8) & 0xff);
2630 case PLOGX_IOCBERR_NOFABRIC:
2633 case PLOGX_IOCBERR_NOTREADY:
2634 msg = "firmware not ready";
2636 case PLOGX_IOCBERR_NOLOGIN:
2637 ISP_SNPRINTF(buf, sizeof (buf), "not logged in (last state 0x%x)", parm1);
2639 rval = MBOX_NOT_LOGGED_IN;
2641 case PLOGX_IOCBERR_REJECT:
2642 ISP_SNPRINTF(buf, sizeof (buf), "LS_RJT = 0x%x", parm1);
2645 case PLOGX_IOCBERR_NOPCB:
2646 msg = "no PCB allocated";
2648 case PLOGX_IOCBERR_EINVAL:
2649 ISP_SNPRINTF(buf, sizeof (buf), "invalid parameter at offset 0x%x", parm1);
2652 case PLOGX_IOCBERR_PORTUSED:
2653 lev = ISP_LOG_SANCFG|ISP_LOG_WARN1;
2654 ISP_SNPRINTF(buf, sizeof (buf), "already logged in with N-Port handle 0x%x", parm1);
2656 rval = MBOX_PORT_ID_USED | (parm1 << 16);
2658 case PLOGX_IOCBERR_HNDLUSED:
2659 lev = ISP_LOG_SANCFG|ISP_LOG_WARN1;
2660 ISP_SNPRINTF(buf, sizeof (buf), "handle already used for PortID 0x%06x", parm1);
2662 rval = MBOX_LOOP_ID_USED;
2664 case PLOGX_IOCBERR_NOHANDLE:
2665 msg = "no handle allocated";
2667 case PLOGX_IOCBERR_NOFLOGI:
2668 msg = "no FLOGI_ACC";
2671 ISP_SNPRINTF(buf, sizeof (buf), "status %x from %x", pl.plogx_status, flags);
2676 isp_prt(isp, lev, "Chan %d PLOGX PortID 0x%06x to N-Port handle 0x%x: %s",
2677 chan, portid, handle, msg);
2683 isp_port_login(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2687 MBSINIT(&mbs, MBOX_FABRIC_LOGIN, MBLOGNONE, 500000);
2688 if (ISP_CAP_2KLOGIN(isp)) {
2689 mbs.param[1] = handle;
2690 mbs.ibits = (1 << 10);
2692 mbs.param[1] = handle << 8;
2694 mbs.param[2] = portid >> 16;
2695 mbs.param[3] = portid;
2696 mbs.logval = MBLOGNONE;
2697 mbs.timeout = 500000;
2698 isp_mboxcmd(isp, &mbs);
2700 switch (mbs.param[0]) {
2701 case MBOX_PORT_ID_USED:
2702 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]);
2703 return (MBOX_PORT_ID_USED | (mbs.param[1] << 16));
2705 case MBOX_LOOP_ID_USED:
2706 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);
2707 return (MBOX_LOOP_ID_USED);
2709 case MBOX_COMMAND_COMPLETE:
2712 case MBOX_COMMAND_ERROR:
2713 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);
2714 return (MBOX_COMMAND_ERROR);
2716 case MBOX_ALL_IDS_USED:
2717 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: all IDs used for fabric login");
2718 return (MBOX_ALL_IDS_USED);
2721 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);
2722 return (mbs.param[0]);
2727 * Pre-24XX fabric port logout
2729 * Note that portid is not used
2732 isp_port_logout(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2736 MBSINIT(&mbs, MBOX_FABRIC_LOGOUT, MBLOGNONE, 500000);
2737 if (ISP_CAP_2KLOGIN(isp)) {
2738 mbs.param[1] = handle;
2739 mbs.ibits = (1 << 10);
2741 mbs.param[1] = handle << 8;
2743 isp_mboxcmd(isp, &mbs);
2744 return (mbs.param[0] == MBOX_COMMAND_COMPLETE? 0 : mbs.param[0]);
2748 isp_getpdb(ispsoftc_t *isp, int chan, uint16_t id, isp_pdb_t *pdb)
2752 isp_pdb_21xx_t fred;
2753 isp_pdb_24xx_t bill;
2756 MBSINIT(&mbs, MBOX_GET_PORT_DB,
2757 MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_PARAM_ERROR), 250000);
2759 mbs.ibits = (1 << 9)|(1 << 10);
2761 mbs.param[9] = chan;
2762 } else if (ISP_CAP_2KLOGIN(isp)) {
2765 mbs.param[1] = id << 8;
2767 mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
2768 mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
2769 mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
2770 mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
2771 MEMORYBARRIER(isp, SYNC_IFORDEV, 0, sizeof(un), chan);
2773 isp_mboxcmd(isp, &mbs);
2774 if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
2775 return (mbs.param[0] | (mbs.param[1] << 16));
2777 MEMORYBARRIER(isp, SYNC_IFORCPU, 0, sizeof(un), chan);
2779 isp_get_pdb_24xx(isp, isp->isp_iocb, &un.bill);
2780 pdb->handle = un.bill.pdb_handle;
2781 pdb->prli_word3 = un.bill.pdb_prli_svc3;
2782 pdb->portid = BITS2WORD_24XX(un.bill.pdb_portid_bits);
2783 ISP_MEMCPY(pdb->portname, un.bill.pdb_portname, 8);
2784 ISP_MEMCPY(pdb->nodename, un.bill.pdb_nodename, 8);
2785 isp_prt(isp, ISP_LOGDEBUG0,
2786 "Chan %d handle 0x%x Port 0x%06x flags 0x%x curstate %x laststate %x",
2787 chan, id, pdb->portid, un.bill.pdb_flags,
2788 un.bill.pdb_curstate, un.bill.pdb_laststate);
2790 if (un.bill.pdb_curstate < PDB2400_STATE_PLOGI_DONE || un.bill.pdb_curstate > PDB2400_STATE_LOGGED_IN) {
2791 mbs.param[0] = MBOX_NOT_LOGGED_IN;
2792 return (mbs.param[0]);
2795 isp_get_pdb_21xx(isp, isp->isp_iocb, &un.fred);
2796 pdb->handle = un.fred.pdb_loopid;
2797 pdb->prli_word3 = un.fred.pdb_prli_svc3;
2798 pdb->portid = BITS2WORD(un.fred.pdb_portid_bits);
2799 ISP_MEMCPY(pdb->portname, un.fred.pdb_portname, 8);
2800 ISP_MEMCPY(pdb->nodename, un.fred.pdb_nodename, 8);
2801 isp_prt(isp, ISP_LOGDEBUG1,
2802 "Chan %d handle 0x%x Port 0x%06x", chan, id, pdb->portid);
2808 isp_gethandles(ispsoftc_t *isp, int chan, uint16_t *handles, int *num, int loop)
2810 fcparam *fcp = FCPARAM(isp, chan);
2812 isp_pnhle_21xx_t el1, *elp1;
2813 isp_pnhle_23xx_t el3, *elp3;
2814 isp_pnhle_24xx_t el4, *elp4;
2819 MBSINIT(&mbs, MBOX_GET_ID_LIST, MBLOGALL, 250000);
2821 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2822 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2823 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2824 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2825 mbs.param[8] = ISP_FC_SCRLEN;
2826 mbs.param[9] = chan;
2828 mbs.ibits = (1 << 1)|(1 << 2)|(1 << 3)|(1 << 6);
2829 mbs.param[1] = DMA_WD1(fcp->isp_scdma);
2830 mbs.param[2] = DMA_WD0(fcp->isp_scdma);
2831 mbs.param[3] = DMA_WD3(fcp->isp_scdma);
2832 mbs.param[6] = DMA_WD2(fcp->isp_scdma);
2834 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2835 isp_prt(isp, ISP_LOGERR, sacq);
2838 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, ISP_FC_SCRLEN, chan);
2839 isp_mboxcmd(isp, &mbs);
2840 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2841 FC_SCRATCH_RELEASE(isp, chan);
2842 return (mbs.param[0] | (mbs.param[1] << 16));
2844 MEMORYBARRIER(isp, SYNC_SFORCPU, 0, ISP_FC_SCRLEN, chan);
2845 elp1 = fcp->isp_scratch;
2846 elp3 = fcp->isp_scratch;
2847 elp4 = fcp->isp_scratch;
2848 for (i = 0, j = 0; i < mbs.param[1] && j < *num; i++) {
2850 isp_get_pnhle_24xx(isp, &elp4[i], &el4);
2851 p = el4.pnhle_port_id_lo |
2852 (el4.pnhle_port_id_hi << 16);
2853 h = el4.pnhle_handle;
2854 } else if (IS_23XX(isp)) {
2855 isp_get_pnhle_23xx(isp, &elp3[i], &el3);
2856 p = el3.pnhle_port_id_lo |
2857 (el3.pnhle_port_id_hi << 16);
2858 h = el3.pnhle_handle;
2860 isp_get_pnhle_21xx(isp, &elp1[i], &el1);
2861 p = el1.pnhle_port_id_lo |
2862 ((el1.pnhle_port_id_hi_handle & 0xff) << 16);
2863 h = el1.pnhle_port_id_hi_handle >> 8;
2865 if (loop && (p >> 8) != (fcp->isp_portid >> 8))
2870 FC_SCRATCH_RELEASE(isp, chan);
2875 isp_dump_chip_portdb(ispsoftc_t *isp, int chan)
2878 uint16_t lim, nphdl;
2880 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d chip port dump", chan);
2881 if (ISP_CAP_2KLOGIN(isp)) {
2886 for (nphdl = 0; nphdl != lim; nphdl++) {
2887 if (isp_getpdb(isp, chan, nphdl, &pdb)) {
2890 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d Handle 0x%04x "
2891 "PortID 0x%06x WWPN 0x%02x%02x%02x%02x%02x%02x%02x%02x",
2892 chan, nphdl, pdb.portid, pdb.portname[0], pdb.portname[1],
2893 pdb.portname[2], pdb.portname[3], pdb.portname[4],
2894 pdb.portname[5], pdb.portname[6], pdb.portname[7]);
2899 isp_get_wwn(ispsoftc_t *isp, int chan, int nphdl, int nodename)
2901 uint64_t wwn = INI_NONE;
2904 MBSINIT(&mbs, MBOX_GET_PORT_NAME,
2905 MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_PARAM_ERROR), 500000);
2906 if (ISP_CAP_2KLOGIN(isp)) {
2907 mbs.param[1] = nphdl;
2911 mbs.param[9] = chan;
2914 mbs.param[1] = nphdl << 8;
2919 isp_mboxcmd(isp, &mbs);
2920 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2925 (((uint64_t)(mbs.param[2] >> 8)) << 56) |
2926 (((uint64_t)(mbs.param[2] & 0xff)) << 48) |
2927 (((uint64_t)(mbs.param[3] >> 8)) << 40) |
2928 (((uint64_t)(mbs.param[3] & 0xff)) << 32) |
2929 (((uint64_t)(mbs.param[6] >> 8)) << 24) |
2930 (((uint64_t)(mbs.param[6] & 0xff)) << 16) |
2931 (((uint64_t)(mbs.param[7] >> 8)) << 8) |
2932 (((uint64_t)(mbs.param[7] & 0xff)));
2935 (((uint64_t)(mbs.param[2] & 0xff)) << 56) |
2936 (((uint64_t)(mbs.param[2] >> 8)) << 48) |
2937 (((uint64_t)(mbs.param[3] & 0xff)) << 40) |
2938 (((uint64_t)(mbs.param[3] >> 8)) << 32) |
2939 (((uint64_t)(mbs.param[6] & 0xff)) << 24) |
2940 (((uint64_t)(mbs.param[6] >> 8)) << 16) |
2941 (((uint64_t)(mbs.param[7] & 0xff)) << 8) |
2942 (((uint64_t)(mbs.param[7] >> 8)));
2948 * Make sure we have good FC link.
2952 isp_fclink_test(ispsoftc_t *isp, int chan, int usdelay)
2959 NANOTIME_T hra, hrb;
2961 fcp = FCPARAM(isp, chan);
2963 if (fcp->isp_loopstate < LOOP_HAVE_LINK)
2965 if (fcp->isp_loopstate >= LOOP_LTEST_DONE)
2968 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test", chan);
2971 * Wait up to N microseconds for F/W to go to a ready state.
2975 isp_change_fw_state(isp, chan, isp_fw_state(isp, chan));
2976 if (fcp->isp_fwstate == FW_READY) {
2979 if (fcp->isp_loopstate < LOOP_HAVE_LINK)
2982 if ((NANOTIME_SUB(&hrb, &hra) / 1000 + 1000 >= usdelay))
2984 ISP_SLEEP(isp, 1000);
2986 if (fcp->isp_fwstate != FW_READY) {
2987 isp_prt(isp, ISP_LOG_SANCFG,
2988 "Chan %d Firmware is not ready (%s)",
2989 chan, isp_fc_fw_statename(fcp->isp_fwstate));
2994 * Get our Loop ID and Port ID.
2996 MBSINIT(&mbs, MBOX_GET_LOOP_ID, MBLOGALL, 0);
2997 mbs.param[9] = chan;
2998 isp_mboxcmd(isp, &mbs);
2999 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3005 * Don't bother with fabric if we are using really old
3006 * 2100 firmware. It's just not worth it.
3008 if (ISP_FW_NEWER_THAN(isp, 1, 15, 37))
3009 fcp->isp_topo = TOPO_FL_PORT;
3011 fcp->isp_topo = TOPO_NL_PORT;
3013 int topo = (int) mbs.param[6];
3014 if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB) {
3015 topo = TOPO_PTP_STUB;
3017 fcp->isp_topo = topo;
3019 fcp->isp_portid = mbs.param[2] | (mbs.param[3] << 16);
3021 if (!TOPO_IS_FABRIC(fcp->isp_topo)) {
3022 fcp->isp_loopid = mbs.param[1] & 0xff;
3023 } else if (fcp->isp_topo != TOPO_F_PORT) {
3024 uint8_t alpa = fcp->isp_portid;
3026 for (i = 0; alpa_map[i]; i++) {
3027 if (alpa_map[i] == alpa)
3031 fcp->isp_loopid = i;
3035 fcp->isp_loopstate = LOOP_HAVE_ADDR;
3037 fcp->isp_loopstate = LOOP_TESTING_LINK;
3039 if (fcp->isp_topo == TOPO_F_PORT || fcp->isp_topo == TOPO_FL_PORT) {
3040 nphdl = IS_24XX(isp) ? NPH_FL_ID : FL_ID;
3041 r = isp_getpdb(isp, chan, nphdl, &pdb);
3042 if (r != 0 || pdb.portid == 0) {
3044 fcp->isp_topo = TOPO_NL_PORT;
3046 isp_prt(isp, ISP_LOGWARN,
3047 "fabric topology, but cannot get info about fabric controller (0x%x)", r);
3048 fcp->isp_topo = TOPO_PTP_STUB;
3054 fcp->isp_fabric_params = mbs.param[7];
3055 fcp->isp_sns_hdl = NPH_SNS_ID;
3056 r = isp_register_fc4_type(isp, chan);
3057 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3061 r = isp_register_fc4_features_24xx(isp, chan);
3062 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3066 r = isp_register_port_name_24xx(isp, chan);
3067 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3071 isp_register_node_name_24xx(isp, chan);
3072 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3075 fcp->isp_sns_hdl = SNS_ID;
3076 r = isp_register_fc4_type(isp, chan);
3079 if (fcp->role == ISP_ROLE_TARGET)
3080 isp_send_change_request(isp, chan);
3085 /* Get link speed. */
3086 fcp->isp_gbspeed = 1;
3087 if (IS_23XX(isp) || IS_24XX(isp)) {
3088 MBSINIT(&mbs, MBOX_GET_SET_DATA_RATE, MBLOGALL, 3000000);
3089 mbs.param[1] = MBGSD_GET_RATE;
3090 /* mbs.param[2] undefined if we're just getting rate */
3091 isp_mboxcmd(isp, &mbs);
3092 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3093 if (mbs.param[1] == MBGSD_10GB)
3094 fcp->isp_gbspeed = 10;
3095 else if (mbs.param[1] == MBGSD_16GB)
3096 fcp->isp_gbspeed = 16;
3097 else if (mbs.param[1] == MBGSD_8GB)
3098 fcp->isp_gbspeed = 8;
3099 else if (mbs.param[1] == MBGSD_4GB)
3100 fcp->isp_gbspeed = 4;
3101 else if (mbs.param[1] == MBGSD_2GB)
3102 fcp->isp_gbspeed = 2;
3103 else if (mbs.param[1] == MBGSD_1GB)
3104 fcp->isp_gbspeed = 1;
3108 if (fcp->isp_loopstate < LOOP_TESTING_LINK) {
3110 isp_prt(isp, ISP_LOG_SANCFG,
3111 "Chan %d FC link test aborted", chan);
3114 fcp->isp_loopstate = LOOP_LTEST_DONE;
3115 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
3116 "Chan %d WWPN %016jx WWNN %016jx",
3117 chan, (uintmax_t)fcp->isp_wwpn, (uintmax_t)fcp->isp_wwnn);
3118 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
3119 "Chan %d %dGb %s PortID 0x%06x LoopID 0x%02x",
3120 chan, fcp->isp_gbspeed, isp_fc_toponame(fcp), fcp->isp_portid,
3122 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test done", chan);
3127 * Complete the synchronization of our Port Database.
3129 * At this point, we've scanned the local loop (if any) and the fabric
3130 * and performed fabric logins on all new devices.
3132 * Our task here is to go through our port database removing any entities
3133 * that are still marked probational (issuing PLOGO for ones which we had
3134 * PLOGI'd into) or are dead, and notifying upper layers about new/changed
3138 isp_pdb_sync(ispsoftc_t *isp, int chan)
3140 fcparam *fcp = FCPARAM(isp, chan);
3144 if (fcp->isp_loopstate < LOOP_FSCAN_DONE)
3146 if (fcp->isp_loopstate >= LOOP_READY)
3149 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync", chan);
3151 fcp->isp_loopstate = LOOP_SYNCING_PDB;
3153 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3154 lp = &fcp->portdb[dbidx];
3156 if (lp->state == FC_PORTDB_STATE_NIL)
3158 if (lp->probational && lp->state != FC_PORTDB_STATE_ZOMBIE)
3159 lp->state = FC_PORTDB_STATE_DEAD;
3160 switch (lp->state) {
3161 case FC_PORTDB_STATE_DEAD:
3162 lp->state = FC_PORTDB_STATE_NIL;
3163 isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
3164 if ((lp->portid & 0xffff00) != 0) {
3165 (void) isp_plogx(isp, chan, lp->handle,
3167 PLOGX_FLG_CMD_LOGO |
3168 PLOGX_FLG_IMPLICIT |
3169 PLOGX_FLG_FREE_NPHDL);
3172 * Note that we might come out of this with our state
3173 * set to FC_PORTDB_STATE_ZOMBIE.
3176 case FC_PORTDB_STATE_NEW:
3177 lp->state = FC_PORTDB_STATE_VALID;
3178 isp_async(isp, ISPASYNC_DEV_ARRIVED, chan, lp);
3180 case FC_PORTDB_STATE_CHANGED:
3181 lp->state = FC_PORTDB_STATE_VALID;
3182 isp_async(isp, ISPASYNC_DEV_CHANGED, chan, lp);
3183 lp->portid = lp->new_portid;
3184 lp->prli_word3 = lp->new_prli_word3;
3186 case FC_PORTDB_STATE_VALID:
3187 isp_async(isp, ISPASYNC_DEV_STAYED, chan, lp);
3189 case FC_PORTDB_STATE_ZOMBIE:
3192 isp_prt(isp, ISP_LOGWARN,
3193 "isp_pdb_sync: state %d for idx %d",
3195 isp_dump_portdb(isp, chan);
3199 if (fcp->isp_loopstate < LOOP_SYNCING_PDB) {
3200 isp_prt(isp, ISP_LOG_SANCFG,
3201 "Chan %d FC PDB sync aborted", chan);
3205 fcp->isp_loopstate = LOOP_READY;
3206 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync done", chan);
3211 isp_pdb_add_update(ispsoftc_t *isp, int chan, isp_pdb_t *pdb)
3214 uint64_t wwnn, wwpn;
3216 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb->nodename);
3217 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb->portname);
3219 /* Search port database for the same WWPN. */
3220 if (isp_find_pdb_by_wwpn(isp, chan, wwpn, &lp)) {
3221 if (!lp->probational) {
3222 isp_prt(isp, ISP_LOGERR,
3223 "Chan %d Port 0x%06x@0x%04x [%d] is not probational (0x%x)",
3224 chan, lp->portid, lp->handle,
3225 FC_PORTDB_TGT(isp, chan, lp), lp->state);
3226 isp_dump_portdb(isp, chan);
3229 lp->probational = 0;
3230 lp->node_wwn = wwnn;
3232 /* Old device, nothing new. */
3233 if (lp->portid == pdb->portid &&
3234 lp->handle == pdb->handle &&
3235 lp->prli_word3 == pdb->prli_word3) {
3236 if (lp->state != FC_PORTDB_STATE_NEW)
3237 lp->state = FC_PORTDB_STATE_VALID;
3238 isp_prt(isp, ISP_LOG_SANCFG,
3239 "Chan %d Port 0x%06x@0x%04x is valid",
3240 chan, pdb->portid, pdb->handle);
3244 /* Something has changed. */
3245 lp->state = FC_PORTDB_STATE_CHANGED;
3246 lp->handle = pdb->handle;
3247 lp->new_portid = pdb->portid;
3248 lp->new_prli_word3 = pdb->prli_word3;
3249 isp_prt(isp, ISP_LOG_SANCFG,
3250 "Chan %d Port 0x%06x@0x%04x is changed",
3251 chan, pdb->portid, pdb->handle);
3255 /* It seems like a new port. Find an empty slot for it. */
3256 if (!isp_find_pdb_empty(isp, chan, &lp)) {
3257 isp_prt(isp, ISP_LOGERR, "Chan %d out of portdb entries", chan);
3261 ISP_MEMZERO(lp, sizeof (fcportdb_t));
3262 lp->probational = 0;
3263 lp->state = FC_PORTDB_STATE_NEW;
3264 lp->portid = lp->new_portid = pdb->portid;
3265 lp->prli_word3 = lp->new_prli_word3 = pdb->prli_word3;
3266 lp->handle = pdb->handle;
3267 lp->port_wwn = wwpn;
3268 lp->node_wwn = wwnn;
3269 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Port 0x%06x@0x%04x is new",
3270 chan, pdb->portid, pdb->handle);
3274 * Fix port IDs for logged-in initiators on pre-2400 chips.
3275 * For those chips we are not receiving login events, adding initiators
3276 * based on ATIO requests, but there is no port ID in that structure.
3279 isp_fix_portids(ispsoftc_t *isp, int chan)
3281 fcparam *fcp = FCPARAM(isp, chan);
3286 for (i = 0; i < MAX_FC_TARG; i++) {
3287 fcportdb_t *lp = &fcp->portdb[i];
3289 if (lp->state == FC_PORTDB_STATE_NIL ||
3290 lp->state == FC_PORTDB_STATE_ZOMBIE)
3292 if (VALID_PORT(lp->portid))
3295 r = isp_getpdb(isp, chan, lp->handle, &pdb);
3296 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3299 isp_prt(isp, ISP_LOGDEBUG1,
3300 "Chan %d FC Scan Loop handle %d returned %x",
3301 chan, lp->handle, r);
3305 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3306 if (lp->port_wwn != wwpn)
3308 lp->portid = lp->new_portid = pdb.portid;
3309 isp_prt(isp, ISP_LOG_SANCFG,
3310 "Chan %d Port 0x%06x@0x%04x is fixed",
3311 chan, pdb.portid, pdb.handle);
3316 * Scan local loop for devices.
3319 isp_scan_loop(ispsoftc_t *isp, int chan)
3321 fcparam *fcp = FCPARAM(isp, chan);
3327 if (fcp->isp_loopstate < LOOP_LTEST_DONE)
3329 if (fcp->isp_loopstate >= LOOP_LSCAN_DONE)
3332 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan", chan);
3333 fcp->isp_loopstate = LOOP_SCANNING_LOOP;
3334 if (TOPO_IS_FABRIC(fcp->isp_topo)) {
3335 if (!IS_24XX(isp)) {
3336 isp_fix_portids(isp, chan);
3337 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3340 isp_prt(isp, ISP_LOG_SANCFG,
3341 "Chan %d FC loop scan done (no loop)", chan);
3342 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3346 handles = (uint16_t *)fcp->isp_scanscratch;
3347 lim = ISP_FC_SCRLEN / 2;
3348 r = isp_gethandles(isp, chan, handles, &lim, 1);
3350 isp_prt(isp, ISP_LOG_SANCFG,
3351 "Chan %d Getting list of handles failed with %x", chan, r);
3352 isp_prt(isp, ISP_LOG_SANCFG,
3353 "Chan %d FC loop scan done (bad)", chan);
3357 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Got %d handles",
3361 * Run through the list and get the port database info for each one.
3363 isp_mark_portdb(isp, chan);
3364 for (idx = 0; idx < lim; idx++) {
3365 handle = handles[idx];
3368 * Don't scan "special" ids.
3370 if (ISP_CAP_2KLOGIN(isp)) {
3371 if (handle >= NPH_RESERVED)
3374 if (handle >= FL_ID && handle <= SNS_ID)
3379 * In older cards with older f/w GET_PORT_DATABASE has been
3380 * known to hang. This trick gets around that problem.
3382 if (IS_2100(isp) || IS_2200(isp)) {
3383 uint64_t node_wwn = isp_get_wwn(isp, chan, handle, 1);
3384 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
3386 isp_prt(isp, ISP_LOG_SANCFG,
3387 "Chan %d FC loop scan aborted", chan);
3390 if (node_wwn == INI_NONE) {
3396 * Get the port database entity for this index.
3398 r = isp_getpdb(isp, chan, handle, &pdb);
3399 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3402 isp_prt(isp, ISP_LOGDEBUG1,
3403 "Chan %d FC Scan Loop handle %d returned %x",
3408 isp_pdb_add_update(isp, chan, &pdb);
3410 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3412 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3413 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan done", chan);
3418 isp_ct_sns(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
3420 fcparam *fcp = FCPARAM(isp, chan);
3423 if (isp->isp_dblev & ISP_LOGDEBUG1)
3424 isp_print_bytes(isp, "CT SNS request", cmd_bcnt, fcp->isp_scratch);
3425 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, cmd_bcnt, chan);
3427 MBSINIT(&mbs, MBOX_SEND_SNS, MBLOGALL, 10000000);
3428 mbs.param[1] = cmd_bcnt >> 1;
3429 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
3430 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
3431 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
3432 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
3433 isp_mboxcmd(isp, &mbs);
3434 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3435 if (mbs.param[0] == MBOX_INVALID_COMMAND) {
3442 MEMORYBARRIER(isp, SYNC_SFORCPU, 0, rsp_bcnt, chan);
3443 if (isp->isp_dblev & ISP_LOGDEBUG1)
3444 isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
3449 isp_ct_passthru(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
3451 fcparam *fcp = FCPARAM(isp, chan);
3454 uint8_t resp[QENTRY_LEN];
3456 if (isp->isp_dblev & ISP_LOGDEBUG1)
3457 isp_print_bytes(isp, "CT request", cmd_bcnt, fcp->isp_scratch);
3460 * Build a Passthrough IOCB in memory.
3462 ISP_MEMZERO(&pt, sizeof(pt));
3463 pt.ctp_header.rqs_entry_count = 1;
3464 pt.ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
3465 pt.ctp_nphdl = fcp->isp_sns_hdl;
3467 pt.ctp_vpidx = ISP_GET_VPIDX(isp, chan);
3470 pt.ctp_rsp_bcnt = rsp_bcnt;
3471 pt.ctp_cmd_bcnt = cmd_bcnt;
3472 pt.ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma);
3473 pt.ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma);
3474 pt.ctp_dataseg[0].ds_count = cmd_bcnt;
3475 pt.ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma);
3476 pt.ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma);
3477 pt.ctp_dataseg[1].ds_count = rsp_bcnt;
3479 /* Prepare space for response in memory */
3480 memset(resp, 0xff, sizeof(resp));
3481 pt.ctp_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
3482 if (pt.ctp_handle == 0) {
3483 isp_prt(isp, ISP_LOGERR,
3484 "%s: CTP of Chan %d out of handles", __func__, chan);
3488 /* Send request and wait for response. */
3489 reqp = isp_getrqentry(isp);
3491 isp_prt(isp, ISP_LOGERR,
3492 "%s: CTP of Chan %d out of rqent", __func__, chan);
3493 isp_destroy_handle(isp, pt.ctp_handle);
3496 isp_put_ct_pt(isp, &pt, (isp_ct_pt_t *)reqp);
3497 if (isp->isp_dblev & ISP_LOGDEBUG1)
3498 isp_print_bytes(isp, "CT IOCB request", QENTRY_LEN, reqp);
3499 ISP_SYNC_REQUEST(isp);
3500 if (msleep(resp, &isp->isp_lock, 0, "CTP", pt.ctp_time*hz) == EWOULDBLOCK) {
3501 isp_prt(isp, ISP_LOGERR,
3502 "%s: CTP of Chan %d timed out", __func__, chan);
3503 isp_destroy_handle(isp, pt.ctp_handle);
3506 if (isp->isp_dblev & ISP_LOGDEBUG1)
3507 isp_print_bytes(isp, "CT IOCB response", QENTRY_LEN, resp);
3509 isp_get_ct_pt(isp, (isp_ct_pt_t *)resp, &pt);
3510 if (pt.ctp_status && pt.ctp_status != RQCS_DATA_UNDERRUN) {
3511 isp_prt(isp, ISP_LOGWARN,
3512 "Chan %d CT pass-through returned 0x%x",
3513 chan, pt.ctp_status);
3517 if (isp->isp_dblev & ISP_LOGDEBUG1)
3518 isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
3524 * Scan the fabric for devices and add them to our port database.
3526 * Use the GID_PT command to get list of all Nx_Port IDs SNS knows.
3527 * Use GFF_ID and GFT_ID to check port type (FCP) and features (target).
3529 * For 2100-23XX cards, we use the SNS mailbox command to pass simple name
3530 * server commands to the switch management server via the QLogic f/w.
3532 * For the 24XX and above card, we use CT Pass-through IOCB.
3534 #define GIDLEN ISP_FC_SCRLEN
3535 #define NGENT ((GIDLEN - 16) >> 2)
3538 isp_gid_pt(ispsoftc_t *isp, int chan)
3540 fcparam *fcp = FCPARAM(isp, chan);
3542 sns_gid_pt_req_t rq;
3543 uint8_t *scp = fcp->isp_scratch;
3545 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GID_PT", chan);
3546 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3547 isp_prt(isp, ISP_LOGERR, sacq);
3552 /* Build the CT command and execute via pass-through. */
3553 ISP_MEMZERO(&ct, sizeof (ct));
3554 ct.ct_revision = CT_REVISION;
3555 ct.ct_fcs_type = CT_FC_TYPE_FC;
3556 ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3557 ct.ct_cmd_resp = SNS_GID_PT;
3558 ct.ct_bcnt_resid = (GIDLEN - 16) >> 2;
3559 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3560 scp[sizeof(ct)] = 0x7f; /* Port Type = Nx_Port */
3561 scp[sizeof(ct)+1] = 0; /* Domain_ID = any */
3562 scp[sizeof(ct)+2] = 0; /* Area_ID = any */
3563 scp[sizeof(ct)+3] = 0; /* Flags = no Area_ID */
3565 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t), GIDLEN)) {
3566 FC_SCRATCH_RELEASE(isp, chan);
3570 /* Build the SNS request and execute via firmware. */
3571 ISP_MEMZERO(&rq, SNS_GID_PT_REQ_SIZE);
3572 rq.snscb_rblen = GIDLEN >> 1;
3573 rq.snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma);
3574 rq.snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma);
3575 rq.snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma);
3576 rq.snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma);
3578 rq.snscb_cmd = SNS_GID_PT;
3579 rq.snscb_mword_div_2 = NGENT;
3580 rq.snscb_port_type = 0x7f; /* Port Type = Nx_Port */
3581 rq.snscb_domain = 0; /* Domain_ID = any */
3582 rq.snscb_area = 0; /* Area_ID = any */
3583 rq.snscb_flags = 0; /* Flags = no Area_ID */
3584 isp_put_gid_pt_request(isp, &rq, (sns_gid_pt_req_t *)scp);
3586 if (isp_ct_sns(isp, chan, sizeof(rq), NGENT)) {
3587 FC_SCRATCH_RELEASE(isp, chan);
3592 isp_get_gid_xx_response(isp, (sns_gid_xx_rsp_t *)scp,
3593 (sns_gid_xx_rsp_t *)fcp->isp_scanscratch, NGENT);
3594 FC_SCRATCH_RELEASE(isp, chan);
3599 isp_gff_id(ispsoftc_t *isp, int chan, uint32_t portid)
3601 fcparam *fcp = FCPARAM(isp, chan);
3604 uint8_t *scp = fcp->isp_scratch;
3605 sns_gff_id_rsp_t rsp;
3608 if (!fcp->isp_use_gff_id) /* User may block GFF_ID use. */
3611 if (!IS_24XX(isp)) /* Old chips can't request GFF_ID. */
3614 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFF_ID", chan);
3615 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3616 isp_prt(isp, ISP_LOGERR, sacq);
3620 /* Build the CT command and execute via pass-through. */
3621 ISP_MEMZERO(&ct, sizeof (ct));
3622 ct.ct_revision = CT_REVISION;
3623 ct.ct_fcs_type = CT_FC_TYPE_FC;
3624 ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3625 ct.ct_cmd_resp = SNS_GFF_ID;
3626 ct.ct_bcnt_resid = (SNS_GFF_ID_RESP_SIZE - sizeof(ct)) / 4;
3627 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3628 rp = (uint32_t *) &scp[sizeof(ct)];
3629 ISP_IOZPUT_32(isp, portid, rp);
3631 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
3632 SNS_GFF_ID_RESP_SIZE)) {
3633 FC_SCRATCH_RELEASE(isp, chan);
3637 isp_get_gff_id_response(isp, (sns_gff_id_rsp_t *)scp, &rsp);
3638 if (rsp.snscb_cthdr.ct_cmd_resp == LS_ACC) {
3639 for (i = 0; i < 32; i++) {
3640 if (rsp.snscb_fc4_features[i] != 0) {
3645 if (((rsp.snscb_fc4_features[FC4_SCSI / 8] >>
3646 ((FC4_SCSI % 8) * 4)) & 0x01) != 0)
3648 /* Workaround for broken Brocade firmware. */
3649 if (((ISP_SWAP32(isp, rsp.snscb_fc4_features[FC4_SCSI / 8]) >>
3650 ((FC4_SCSI % 8) * 4)) & 0x01) != 0)
3653 FC_SCRATCH_RELEASE(isp, chan);
3654 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFF_ID result is %d", chan, res);
3659 isp_gft_id(ispsoftc_t *isp, int chan, uint32_t portid)
3661 fcparam *fcp = FCPARAM(isp, chan);
3663 sns_gxx_id_req_t rq;
3665 uint8_t *scp = fcp->isp_scratch;
3666 sns_gft_id_rsp_t rsp;
3669 if (!fcp->isp_use_gft_id) /* User may block GFT_ID use. */
3672 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFT_ID", chan);
3673 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3674 isp_prt(isp, ISP_LOGERR, sacq);
3679 /* Build the CT command and execute via pass-through. */
3680 ISP_MEMZERO(&ct, sizeof (ct));
3681 ct.ct_revision = CT_REVISION;
3682 ct.ct_fcs_type = CT_FC_TYPE_FC;
3683 ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3684 ct.ct_cmd_resp = SNS_GFT_ID;
3685 ct.ct_bcnt_resid = (SNS_GFT_ID_RESP_SIZE - sizeof(ct)) / 4;
3686 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3687 rp = (uint32_t *) &scp[sizeof(ct)];
3688 ISP_IOZPUT_32(isp, portid, rp);
3690 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
3691 SNS_GFT_ID_RESP_SIZE)) {
3692 FC_SCRATCH_RELEASE(isp, chan);
3696 /* Build the SNS request and execute via firmware. */
3697 ISP_MEMZERO(&rq, SNS_GXX_ID_REQ_SIZE);
3698 rq.snscb_rblen = SNS_GFT_ID_RESP_SIZE >> 1;
3699 rq.snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma);
3700 rq.snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma);
3701 rq.snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma);
3702 rq.snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma);
3704 rq.snscb_cmd = SNS_GFT_ID;
3705 rq.snscb_mword_div_2 = (SNS_GFT_ID_RESP_SIZE - sizeof(ct)) / 4;
3706 rq.snscb_portid = portid;
3707 isp_put_gxx_id_request(isp, &rq, (sns_gxx_id_req_t *)scp);
3709 if (isp_ct_sns(isp, chan, sizeof(rq), SNS_GFT_ID_RESP_SIZE)) {
3710 FC_SCRATCH_RELEASE(isp, chan);
3715 isp_get_gft_id_response(isp, (sns_gft_id_rsp_t *)scp, &rsp);
3716 if (rsp.snscb_cthdr.ct_cmd_resp == LS_ACC) {
3717 for (i = 0; i < 8; i++) {
3718 if (rsp.snscb_fc4_types[i] != 0) {
3723 if (((rsp.snscb_fc4_types[FC4_SCSI / 32] >>
3724 (FC4_SCSI % 32)) & 0x01) != 0)
3727 FC_SCRATCH_RELEASE(isp, chan);
3728 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFT_ID result is %d", chan, res);
3733 isp_scan_fabric(ispsoftc_t *isp, int chan)
3735 fcparam *fcp = FCPARAM(isp, chan);
3740 int portidx, portlim, r;
3741 sns_gid_xx_rsp_t *rs;
3743 if (fcp->isp_loopstate < LOOP_LSCAN_DONE)
3745 if (fcp->isp_loopstate >= LOOP_FSCAN_DONE)
3748 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan", chan);
3749 fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
3750 if (!TOPO_IS_FABRIC(fcp->isp_topo)) {
3751 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3752 isp_prt(isp, ISP_LOG_SANCFG,
3753 "Chan %d FC fabric scan done (no fabric)", chan);
3757 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC) {
3759 FC_SCRATCH_RELEASE(isp, chan);
3760 isp_prt(isp, ISP_LOG_SANCFG,
3761 "Chan %d FC fabric scan aborted", chan);
3766 * Make sure we still are logged into the fabric controller.
3768 nphdl = IS_24XX(isp) ? NPH_FL_ID : FL_ID;
3769 r = isp_getpdb(isp, chan, nphdl, &pdb);
3770 if ((r & 0xffff) == MBOX_NOT_LOGGED_IN) {
3771 isp_dump_chip_portdb(isp, chan);
3774 fcp->isp_loopstate = LOOP_LTEST_DONE;
3776 isp_prt(isp, ISP_LOG_SANCFG,
3777 "Chan %d FC fabric scan done (bad)", chan);
3781 /* Get list of port IDs from SNS. */
3782 r = isp_gid_pt(isp, chan);
3783 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3786 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3789 fcp->isp_loopstate = LOOP_LTEST_DONE; /* try again */
3793 rs = (sns_gid_xx_rsp_t *) fcp->isp_scanscratch;
3794 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3796 if (rs->snscb_cthdr.ct_cmd_resp != LS_ACC) {
3798 /* FC-4 Type and Port Type not registered are not errors. */
3799 if (rs->snscb_cthdr.ct_reason == 9 &&
3800 (rs->snscb_cthdr.ct_explanation == 0x07 ||
3801 rs->snscb_cthdr.ct_explanation == 0x0a)) {
3802 level = ISP_LOG_SANCFG;
3804 level = ISP_LOGWARN;
3806 isp_prt(isp, level, "Chan %d Fabric Nameserver rejected GID_PT"
3807 " (Reason=0x%x Expl=0x%x)", chan,
3808 rs->snscb_cthdr.ct_reason,
3809 rs->snscb_cthdr.ct_explanation);
3810 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3814 /* Check our buffer was big enough to get the full list. */
3815 for (portidx = 0; portidx < NGENT-1; portidx++) {
3816 if (rs->snscb_ports[portidx].control & 0x80)
3819 if ((rs->snscb_ports[portidx].control & 0x80) == 0) {
3820 isp_prt(isp, ISP_LOGWARN,
3821 "fabric too big for scratch area: increase ISP_FC_SCRLEN");
3823 portlim = portidx + 1;
3824 isp_prt(isp, ISP_LOG_SANCFG,
3825 "Chan %d Got %d ports back from name server", chan, portlim);
3827 /* Go through the list and remove duplicate port ids. */
3828 for (portidx = 0; portidx < portlim; portidx++) {
3832 ((rs->snscb_ports[portidx].portid[0]) << 16) |
3833 ((rs->snscb_ports[portidx].portid[1]) << 8) |
3834 ((rs->snscb_ports[portidx].portid[2]));
3836 for (npidx = portidx + 1; npidx < portlim; npidx++) {
3837 uint32_t new_portid =
3838 ((rs->snscb_ports[npidx].portid[0]) << 16) |
3839 ((rs->snscb_ports[npidx].portid[1]) << 8) |
3840 ((rs->snscb_ports[npidx].portid[2]));
3841 if (new_portid == portid) {
3846 if (npidx < portlim) {
3847 rs->snscb_ports[npidx].portid[0] = 0;
3848 rs->snscb_ports[npidx].portid[1] = 0;
3849 rs->snscb_ports[npidx].portid[2] = 0;
3850 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d removing duplicate PortID 0x%06x entry from list", chan, portid);
3855 * We now have a list of Port IDs for all FC4 SCSI devices
3856 * that the Fabric Name server knows about.
3858 * For each entry on this list go through our port database looking
3859 * for probational entries- if we find one, then an old entry is
3860 * maybe still this one. We get some information to find out.
3862 * Otherwise, it's a new fabric device, and we log into it
3863 * (unconditionally). After searching the entire database
3864 * again to make sure that we never ever ever ever have more
3865 * than one entry that has the same PortID or the same
3866 * WWNN/WWPN duple, we enter the device into our database.
3868 isp_mark_portdb(isp, chan);
3869 for (portidx = 0; portidx < portlim; portidx++) {
3870 portid = ((rs->snscb_ports[portidx].portid[0]) << 16) |
3871 ((rs->snscb_ports[portidx].portid[1]) << 8) |
3872 ((rs->snscb_ports[portidx].portid[2]));
3873 isp_prt(isp, ISP_LOG_SANCFG,
3874 "Chan %d Checking fabric port 0x%06x", chan, portid);
3876 isp_prt(isp, ISP_LOG_SANCFG,
3877 "Chan %d Port at idx %d is zero",
3881 if (portid == fcp->isp_portid) {
3882 isp_prt(isp, ISP_LOG_SANCFG,
3883 "Chan %d Port 0x%06x is our", chan, portid);
3887 /* Now search the entire port database for the same portid. */
3888 if (isp_find_pdb_by_portid(isp, chan, portid, &lp)) {
3889 if (!lp->probational) {
3890 isp_prt(isp, ISP_LOGERR,
3891 "Chan %d Port 0x%06x@0x%04x [%d] is not probational (0x%x)",
3892 chan, lp->portid, lp->handle,
3893 FC_PORTDB_TGT(isp, chan, lp), lp->state);
3894 isp_dump_portdb(isp, chan);
3898 if (lp->state == FC_PORTDB_STATE_ZOMBIE)
3902 * See if we're still logged into it.
3904 * If we aren't, mark it as a dead device and
3905 * leave the new portid in the database entry
3906 * for somebody further along to decide what to
3907 * do (policy choice).
3909 * If we are, check to see if it's the same
3910 * device still (it should be). If for some
3911 * reason it isn't, mark it as a changed device
3912 * and leave the new portid and role in the
3913 * database entry for somebody further along to
3914 * decide what to do (policy choice).
3916 r = isp_getpdb(isp, chan, lp->handle, &pdb);
3917 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3920 lp->state = FC_PORTDB_STATE_DEAD;
3921 isp_prt(isp, ISP_LOG_SANCFG,
3922 "Chan %d Port 0x%06x handle 0x%x is dead (%d)",
3923 chan, portid, lp->handle, r);
3927 isp_pdb_add_update(isp, chan, &pdb);
3932 if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
3933 isp_prt(isp, ISP_LOG_SANCFG,
3934 "Chan %d Port 0x%06x is not logged in", chan, portid);
3938 r = isp_gff_id(isp, chan, portid);
3940 isp_prt(isp, ISP_LOG_SANCFG,
3941 "Chan %d Port 0x%06x is not an FCP target", chan, portid);
3945 r = isp_gft_id(isp, chan, portid);
3947 isp_prt(isp, ISP_LOG_SANCFG,
3948 "Chan %d Port 0x%06x is not FCP", chan, portid);
3952 if (isp_login_device(isp, chan, portid, &pdb,
3953 &FCPARAM(isp, 0)->isp_lasthdl)) {
3954 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3959 isp_pdb_add_update(isp, chan, &pdb);
3962 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3964 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3965 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan done", chan);
3970 * Find an unused handle and try and use to login to a port.
3973 isp_login_device(ispsoftc_t *isp, int chan, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)
3978 if (ISP_CAP_2KLOGIN(isp)) {
3984 handle = isp_next_handle(isp, ohp);
3985 for (i = 0; i < lim; i++) {
3986 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
3989 /* Check if this handle is free. */
3990 r = isp_getpdb(isp, chan, handle, p);
3992 if (p->portid != portid) {
3993 /* This handle is busy, try next one. */
3994 handle = isp_next_handle(isp, ohp);
3999 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
4003 * Now try and log into the device
4005 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
4008 } else if ((r & 0xffff) == MBOX_PORT_ID_USED) {
4010 * If we get here, then the firmwware still thinks we're logged into this device, but with a different
4011 * handle. We need to break that association. We used to try and just substitute the handle, but then
4012 * failed to get any data via isp_getpdb (below).
4014 if (isp_plogx(isp, chan, r >> 16, portid, PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT | PLOGX_FLG_FREE_NPHDL)) {
4015 isp_prt(isp, ISP_LOGERR, "baw... logout of %x failed", r >> 16);
4017 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
4019 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
4023 } else if ((r & 0xffff) == MBOX_LOOP_ID_USED) {
4024 /* Try the next handle. */
4025 handle = isp_next_handle(isp, ohp);
4034 isp_prt(isp, ISP_LOGWARN, "Chan %d PLOGI 0x%06x failed", chan, portid);
4039 * If we successfully logged into it, get the PDB for it
4040 * so we can crosscheck that it is still what we think it
4041 * is and that we also have the role it plays
4043 r = isp_getpdb(isp, chan, handle, p);
4045 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x disappeared", chan, portid, handle);
4049 if (p->handle != handle || p->portid != portid) {
4050 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
4051 chan, portid, handle, p->portid, p->handle);
4058 isp_send_change_request(ispsoftc_t *isp, int chan)
4062 MBSINIT(&mbs, MBOX_SEND_CHANGE_REQUEST, MBLOGALL, 500000);
4063 mbs.param[1] = 0x03;
4064 mbs.param[9] = chan;
4065 isp_mboxcmd(isp, &mbs);
4066 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
4069 isp_prt(isp, ISP_LOGWARN, "Chan %d Send Change Request: 0x%x",
4070 chan, mbs.param[0]);
4076 isp_register_fc4_type(ispsoftc_t *isp, int chan)
4078 fcparam *fcp = FCPARAM(isp, chan);
4080 ct_hdr_t *ct = &rp.rftid_hdr;
4081 uint8_t local[SNS_RFT_ID_REQ_SIZE];
4082 sns_screq_t *reqp = (sns_screq_t *) local;
4083 uint8_t *scp = fcp->isp_scratch;
4085 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4086 isp_prt(isp, ISP_LOGERR, sacq);
4091 /* Build the CT command and execute via pass-through. */
4092 ISP_MEMZERO(&rp, sizeof(rp));
4093 ct->ct_revision = CT_REVISION;
4094 ct->ct_fcs_type = CT_FC_TYPE_FC;
4095 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4096 ct->ct_cmd_resp = SNS_RFT_ID;
4097 ct->ct_bcnt_resid = (sizeof (rft_id_t) - sizeof (ct_hdr_t)) >> 2;
4098 rp.rftid_portid[0] = fcp->isp_portid >> 16;
4099 rp.rftid_portid[1] = fcp->isp_portid >> 8;
4100 rp.rftid_portid[2] = fcp->isp_portid;
4101 rp.rftid_fc4types[FC4_SCSI >> 5] = 1 << (FC4_SCSI & 0x1f);
4102 isp_put_rft_id(isp, &rp, (rft_id_t *)scp);
4104 if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
4105 FC_SCRATCH_RELEASE(isp, chan);
4109 /* Build the SNS request and execute via firmware. */
4110 ISP_MEMZERO((void *) reqp, SNS_RFT_ID_REQ_SIZE);
4111 reqp->snscb_rblen = sizeof (ct_hdr_t) >> 1;
4112 reqp->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma);
4113 reqp->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma);
4114 reqp->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma);
4115 reqp->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma);
4116 reqp->snscb_sblen = 22;
4117 reqp->snscb_data[0] = SNS_RFT_ID;
4118 reqp->snscb_data[4] = fcp->isp_portid & 0xffff;
4119 reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff;
4120 reqp->snscb_data[6] = (1 << FC4_SCSI);
4121 isp_put_sns_request(isp, reqp, (sns_screq_t *)scp);
4123 if (isp_ct_sns(isp, chan, SNS_RFT_ID_REQ_SIZE, sizeof(ct_hdr_t))) {
4124 FC_SCRATCH_RELEASE(isp, chan);
4129 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4130 FC_SCRATCH_RELEASE(isp, chan);
4131 if (ct->ct_cmd_resp == LS_RJT) {
4132 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "Chan %d Register FC4 Type rejected", chan);
4134 } else if (ct->ct_cmd_resp == LS_ACC) {
4135 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Register FC4 Type accepted", chan);
4137 isp_prt(isp, ISP_LOGWARN, "Chan %d Register FC4 Type: 0x%x", chan, ct->ct_cmd_resp);
4144 isp_register_fc4_features_24xx(ispsoftc_t *isp, int chan)
4146 fcparam *fcp = FCPARAM(isp, chan);
4149 uint8_t *scp = fcp->isp_scratch;
4151 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4152 isp_prt(isp, ISP_LOGERR, sacq);
4157 * Build the CT header and command in memory.
4159 ISP_MEMZERO(&rp, sizeof(rp));
4161 ct->ct_revision = CT_REVISION;
4162 ct->ct_fcs_type = CT_FC_TYPE_FC;
4163 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4164 ct->ct_cmd_resp = SNS_RFF_ID;
4165 ct->ct_bcnt_resid = (sizeof (rff_id_t) - sizeof (ct_hdr_t)) >> 2;
4166 rp.rffid_portid[0] = fcp->isp_portid >> 16;
4167 rp.rffid_portid[1] = fcp->isp_portid >> 8;
4168 rp.rffid_portid[2] = fcp->isp_portid;
4169 rp.rffid_fc4features = 0;
4170 if (fcp->role & ISP_ROLE_TARGET)
4171 rp.rffid_fc4features |= 1;
4172 if (fcp->role & ISP_ROLE_INITIATOR)
4173 rp.rffid_fc4features |= 2;
4174 rp.rffid_fc4type = FC4_SCSI;
4175 isp_put_rff_id(isp, &rp, (rff_id_t *)scp);
4176 if (isp->isp_dblev & ISP_LOGDEBUG1)
4177 isp_print_bytes(isp, "CT request", sizeof(rft_id_t), scp);
4179 if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
4180 FC_SCRATCH_RELEASE(isp, chan);
4184 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4185 FC_SCRATCH_RELEASE(isp, chan);
4186 if (ct->ct_cmd_resp == LS_RJT) {
4187 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4188 "Chan %d Register FC4 Features rejected", chan);
4190 } else if (ct->ct_cmd_resp == LS_ACC) {
4191 isp_prt(isp, ISP_LOG_SANCFG,
4192 "Chan %d Register FC4 Features accepted", chan);
4194 isp_prt(isp, ISP_LOGWARN,
4195 "Chan %d Register FC4 Features: 0x%x", chan, ct->ct_cmd_resp);
4202 isp_register_port_name_24xx(ispsoftc_t *isp, int chan)
4204 fcparam *fcp = FCPARAM(isp, chan);
4207 uint8_t *scp = fcp->isp_scratch;
4210 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4211 isp_prt(isp, ISP_LOGERR, sacq);
4216 * Build the CT header and command in memory.
4218 ISP_MEMZERO(&rp, sizeof(rp));
4219 ct = &rp.rspnid_hdr;
4220 ct->ct_revision = CT_REVISION;
4221 ct->ct_fcs_type = CT_FC_TYPE_FC;
4222 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4223 ct->ct_cmd_resp = SNS_RSPN_ID;
4224 rp.rspnid_portid[0] = fcp->isp_portid >> 16;
4225 rp.rspnid_portid[1] = fcp->isp_portid >> 8;
4226 rp.rspnid_portid[2] = fcp->isp_portid;
4227 rp.rspnid_length = 0;
4228 len = offsetof(rspn_id_t, rspnid_name);
4229 mtx_lock(&prison0.pr_mtx);
4230 rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
4231 "%s", prison0.pr_hostname[0] ? prison0.pr_hostname : "FreeBSD");
4232 mtx_unlock(&prison0.pr_mtx);
4233 rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
4234 ":%s", device_get_nameunit(isp->isp_dev));
4236 rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
4239 len += rp.rspnid_length;
4240 ct->ct_bcnt_resid = (len - sizeof(ct_hdr_t)) >> 2;
4241 isp_put_rspn_id(isp, &rp, (rspn_id_t *)scp);
4243 if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
4244 FC_SCRATCH_RELEASE(isp, chan);
4248 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4249 FC_SCRATCH_RELEASE(isp, chan);
4250 if (ct->ct_cmd_resp == LS_RJT) {
4251 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4252 "Chan %d Register Symbolic Port Name rejected", chan);
4254 } else if (ct->ct_cmd_resp == LS_ACC) {
4255 isp_prt(isp, ISP_LOG_SANCFG,
4256 "Chan %d Register Symbolic Port Name accepted", chan);
4258 isp_prt(isp, ISP_LOGWARN,
4259 "Chan %d Register Symbolic Port Name: 0x%x", chan, ct->ct_cmd_resp);
4266 isp_register_node_name_24xx(ispsoftc_t *isp, int chan)
4268 fcparam *fcp = FCPARAM(isp, chan);
4271 uint8_t *scp = fcp->isp_scratch;
4274 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4275 isp_prt(isp, ISP_LOGERR, sacq);
4280 * Build the CT header and command in memory.
4282 ISP_MEMZERO(&rp, sizeof(rp));
4283 ct = &rp.rsnnnn_hdr;
4284 ct->ct_revision = CT_REVISION;
4285 ct->ct_fcs_type = CT_FC_TYPE_FC;
4286 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4287 ct->ct_cmd_resp = SNS_RSNN_NN;
4288 MAKE_NODE_NAME_FROM_WWN(rp.rsnnnn_nodename, fcp->isp_wwnn);
4289 rp.rsnnnn_length = 0;
4290 len = offsetof(rsnn_nn_t, rsnnnn_name);
4291 mtx_lock(&prison0.pr_mtx);
4292 rp.rsnnnn_length += sprintf(&scp[len + rp.rsnnnn_length],
4293 "%s", prison0.pr_hostname[0] ? prison0.pr_hostname : "FreeBSD");
4294 mtx_unlock(&prison0.pr_mtx);
4295 len += rp.rsnnnn_length;
4296 ct->ct_bcnt_resid = (len - sizeof(ct_hdr_t)) >> 2;
4297 isp_put_rsnn_nn(isp, &rp, (rsnn_nn_t *)scp);
4299 if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
4300 FC_SCRATCH_RELEASE(isp, chan);
4304 isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4305 FC_SCRATCH_RELEASE(isp, chan);
4306 if (ct->ct_cmd_resp == LS_RJT) {
4307 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4308 "Chan %d Register Symbolic Node Name rejected", chan);
4310 } else if (ct->ct_cmd_resp == LS_ACC) {
4311 isp_prt(isp, ISP_LOG_SANCFG,
4312 "Chan %d Register Symbolic Node Name accepted", chan);
4314 isp_prt(isp, ISP_LOGWARN,
4315 "Chan %d Register Symbolic Node Name: 0x%x", chan, ct->ct_cmd_resp);
4322 isp_next_handle(ispsoftc_t *isp, uint16_t *ohp)
4326 uint16_t handle, minh, maxh;
4329 if (ISP_CAP_2KLOGIN(isp)) {
4331 maxh = NPH_RESERVED - 1;
4339 if (handle == NIL_HANDLE) {
4343 if (handle > maxh) {
4345 isp_prt(isp, ISP_LOGERR, "Out of port handles!");
4346 return (NIL_HANDLE);
4351 for (chan = 0; chan < isp->isp_nchan; chan++) {
4352 fcp = FCPARAM(isp, chan);
4353 if (fcp->role == ISP_ROLE_NONE)
4355 for (i = 0; i < MAX_FC_TARG; i++) {
4356 if (fcp->portdb[i].state != FC_PORTDB_STATE_NIL &&
4357 fcp->portdb[i].handle == handle)
4366 * Start a command. Locking is assumed done in the caller.
4374 uint8_t local[QENTRY_LEN];
4379 int target, dmaresult;
4385 * Check command CDB length, etc.. We really are limited to 16 bytes
4386 * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
4387 * but probably only if we're running fairly new firmware (we'll
4388 * let the old f/w choke on an extended command queue entry).
4391 if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
4392 isp_prt(isp, ISP_LOGERR, "unsupported cdb length (%d, CDB[0]=0x%x)", XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
4393 XS_SETERR(xs, HBA_REQINVAL);
4394 return (CMD_COMPLETE);
4398 * Translate the target to device handle as appropriate, checking
4399 * for correct device state as well.
4401 target = XS_TGT(xs);
4403 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
4405 if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
4406 isp_prt(isp, ISP_LOG_WARN1,
4407 "%d.%d.%jx I am not an initiator",
4408 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4409 XS_SETERR(xs, HBA_SELTIMEOUT);
4410 return (CMD_COMPLETE);
4413 if (isp->isp_state != ISP_RUNSTATE) {
4414 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4415 XS_SETERR(xs, HBA_BOTCH);
4416 return (CMD_COMPLETE);
4419 isp_prt(isp, ISP_LOGDEBUG2, "XS_TGT(xs)=%d", target);
4420 lp = &fcp->portdb[target];
4421 if (target < 0 || target >= MAX_FC_TARG ||
4422 lp->is_target == 0) {
4423 XS_SETERR(xs, HBA_SELTIMEOUT);
4424 return (CMD_COMPLETE);
4426 if (fcp->isp_loopstate != LOOP_READY) {
4427 isp_prt(isp, ISP_LOGDEBUG1,
4428 "%d.%d.%jx loop is not ready",
4429 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4430 return (CMD_RQLATER);
4432 if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
4433 isp_prt(isp, ISP_LOGDEBUG1,
4434 "%d.%d.%jx target zombie",
4435 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4436 return (CMD_RQLATER);
4438 if (lp->state != FC_PORTDB_STATE_VALID) {
4439 isp_prt(isp, ISP_LOGDEBUG1,
4440 "%d.%d.%jx bad db port state 0x%x",
4441 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs), lp->state);
4442 XS_SETERR(xs, HBA_SELTIMEOUT);
4443 return (CMD_COMPLETE);
4446 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4447 if (isp->isp_state != ISP_RUNSTATE) {
4448 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4449 XS_SETERR(xs, HBA_BOTCH);
4450 return (CMD_COMPLETE);
4454 isp_spi_update(isp, XS_CHANNEL(xs));
4461 qep = isp_getrqentry(isp);
4463 isp_prt(isp, ISP_LOG_WARN1, "Request Queue Overflow");
4464 XS_SETERR(xs, HBA_BOTCH);
4465 return (CMD_EAGAIN);
4467 XS_SETERR(xs, HBA_NOERROR);
4470 * Now see if we need to synchronize the ISP with respect to anything.
4471 * We do dual duty here (cough) for synchronizing for buses other
4472 * than which we got here to send a command to.
4474 reqp = (ispreq_t *) local;
4475 ISP_MEMZERO(local, QENTRY_LEN);
4476 if (ISP_TST_SENDMARKER(isp, XS_CHANNEL(xs))) {
4478 isp_marker_24xx_t *m = (isp_marker_24xx_t *) reqp;
4479 m->mrk_header.rqs_entry_count = 1;
4480 m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4481 m->mrk_modifier = SYNC_ALL;
4482 m->mrk_vphdl = XS_CHANNEL(xs);
4483 isp_put_marker_24xx(isp, m, qep);
4485 isp_marker_t *m = (isp_marker_t *) reqp;
4486 m->mrk_header.rqs_entry_count = 1;
4487 m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4488 m->mrk_target = (XS_CHANNEL(xs) << 7); /* bus # */
4489 m->mrk_modifier = SYNC_ALL;
4490 isp_put_marker(isp, m, qep);
4492 ISP_SYNC_REQUEST(isp);
4493 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 0);
4497 reqp->req_header.rqs_entry_count = 1;
4500 * Select and install Header Code.
4501 * Note that it might be overridden before going out
4502 * if we're on a 64 bit platform. The lower level
4503 * code (isp_send_cmd) will select the appropriate
4504 * 64 bit variant if it needs to.
4507 reqp->req_header.rqs_entry_type = RQSTYPE_T7RQS;
4508 } else if (IS_FC(isp)) {
4509 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
4511 if (XS_CDBLEN(xs) > 12) {
4512 reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
4514 reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
4519 * Set task attributes
4524 ttype = XS_TAG_TYPE(xs);
4526 ttype = REQFLAG_STAG;
4528 if (ttype == REQFLAG_OTAG) {
4529 ttype = FCP_CMND_TASK_ATTR_ORDERED;
4530 } else if (ttype == REQFLAG_HTAG) {
4531 ttype = FCP_CMND_TASK_ATTR_HEAD;
4533 ttype = FCP_CMND_TASK_ATTR_SIMPLE;
4535 ((ispreqt7_t *)reqp)->req_task_attribute = ttype;
4536 } else if (IS_FC(isp)) {
4538 * See comment in isp_intr_respq
4540 /* XS_SET_RESID(xs, 0); */
4543 * Fibre Channel always requires some kind of tag.
4544 * The Qlogic drivers seem be happy not to use a tag,
4545 * but this breaks for some devices (IBM drives).
4548 ((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs);
4550 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_STAG;
4553 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4554 if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) && XS_TAG_P(xs)) {
4555 reqp->req_flags = XS_TAG_TYPE(xs);
4560 * NB: we do not support long CDBs (yet)
4562 cdblen = XS_CDBLEN(xs);
4565 if (cdblen > sizeof (reqp->req_cdb)) {
4566 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4567 XS_SETERR(xs, HBA_REQINVAL);
4568 return (CMD_COMPLETE);
4570 reqp->req_target = target | (XS_CHANNEL(xs) << 7);
4571 reqp->req_lun_trn = XS_LUN(xs);
4572 reqp->req_cdblen = cdblen;
4573 tptr = &reqp->req_time;
4574 cdbp = reqp->req_cdb;
4575 } else if (IS_24XX(isp)) {
4576 ispreqt7_t *t7 = (ispreqt7_t *)local;
4578 if (cdblen > sizeof (t7->req_cdb)) {
4579 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4580 XS_SETERR(xs, HBA_REQINVAL);
4581 return (CMD_COMPLETE);
4584 t7->req_nphdl = lp->handle;
4585 t7->req_tidlo = lp->portid;
4586 t7->req_tidhi = lp->portid >> 16;
4587 t7->req_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(xs));
4588 be64enc(t7->req_lun, CAM_EXTLUN_BYTE_SWIZZLE(XS_LUN(xs)));
4589 if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
4590 if (FCP_NEXT_CRN(isp, &t7->req_crn, xs)) {
4591 isp_prt(isp, ISP_LOG_WARN1,
4592 "%d.%d.%jx cannot generate next CRN",
4593 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4594 XS_SETERR(xs, HBA_BOTCH);
4595 return (CMD_EAGAIN);
4598 tptr = &t7->req_time;
4601 ispreqt2_t *t2 = (ispreqt2_t *)local;
4603 if (cdblen > sizeof t2->req_cdb) {
4604 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4605 XS_SETERR(xs, HBA_REQINVAL);
4606 return (CMD_COMPLETE);
4608 if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
4609 if (FCP_NEXT_CRN(isp, &t2->req_crn, xs)) {
4610 isp_prt(isp, ISP_LOG_WARN1,
4611 "%d.%d.%jx cannot generate next CRN",
4612 XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4613 XS_SETERR(xs, HBA_BOTCH);
4614 return (CMD_EAGAIN);
4617 if (ISP_CAP_2KLOGIN(isp)) {
4618 ispreqt2e_t *t2e = (ispreqt2e_t *)local;
4619 t2e->req_target = lp->handle;
4620 t2e->req_scclun = XS_LUN(xs);
4621 tptr = &t2e->req_time;
4622 cdbp = t2e->req_cdb;
4623 } else if (ISP_CAP_SCCFW(isp)) {
4624 t2->req_target = lp->handle;
4625 t2->req_scclun = XS_LUN(xs);
4626 tptr = &t2->req_time;
4629 t2->req_target = lp->handle;
4630 t2->req_lun_trn = XS_LUN(xs);
4631 tptr = &t2->req_time;
4635 *tptr = XS_TIME(xs);
4636 ISP_MEMCPY(cdbp, XS_CDBP(xs), cdblen);
4638 /* Whew. Thankfully the same for type 7 requests */
4639 reqp->req_handle = isp_allocate_handle(isp, xs, ISP_HANDLE_INITIATOR);
4640 if (reqp->req_handle == 0) {
4641 isp_prt(isp, ISP_LOG_WARN1, "out of xflist pointers");
4642 XS_SETERR(xs, HBA_BOTCH);
4643 return (CMD_EAGAIN);
4647 * Set up DMA and/or do any platform dependent swizzling of the request entry
4648 * so that the Qlogic F/W understands what is being asked of it.
4650 * The callee is responsible for adding all requests at this point.
4652 dmaresult = ISP_DMASETUP(isp, xs, reqp);
4653 if (dmaresult != CMD_QUEUED) {
4654 isp_destroy_handle(isp, reqp->req_handle);
4656 * dmasetup sets actual error in packet, and
4657 * return what we were given to return.
4661 isp_xs_prt(isp, xs, ISP_LOGDEBUG0, "START cmd cdb[0]=0x%x datalen %ld", XS_CDBP(xs)[0], (long) XS_XFRLEN(xs));
4662 return (CMD_QUEUED);
4667 * Locks (ints blocked) assumed held.
4671 isp_control(ispsoftc_t *isp, ispctl_t ctl, ...)
4680 case ISPCTL_RESET_BUS:
4682 * Issue a bus reset.
4685 isp_prt(isp, ISP_LOGERR, "BUS RESET NOT IMPLEMENTED");
4687 } else if (IS_FC(isp)) {
4692 chan = va_arg(ap, int);
4694 mbs.param[1] = SDPARAM(isp, chan)->isp_bus_reset_delay;
4695 if (mbs.param[1] < 2) {
4698 mbs.param[2] = chan;
4700 MBSINIT(&mbs, MBOX_BUS_RESET, MBLOGALL, 0);
4701 ISP_SET_SENDMARKER(isp, chan, 1);
4702 isp_mboxcmd(isp, &mbs);
4703 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4706 isp_prt(isp, ISP_LOGINFO, "driver initiated bus reset of bus %d", chan);
4709 case ISPCTL_RESET_DEV:
4711 chan = va_arg(ap, int);
4712 tgt = va_arg(ap, int);
4715 uint8_t local[QENTRY_LEN];
4717 isp24xx_statusreq_t *sp;
4718 fcparam *fcp = FCPARAM(isp, chan);
4721 if (tgt < 0 || tgt >= MAX_FC_TARG) {
4722 isp_prt(isp, ISP_LOGWARN, "Chan %d trying to reset bad target %d", chan, tgt);
4725 lp = &fcp->portdb[tgt];
4726 if (lp->is_target == 0 ||
4727 lp->state != FC_PORTDB_STATE_VALID) {
4728 isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
4732 tmf = (isp24xx_tmf_t *) local;
4733 ISP_MEMZERO(tmf, QENTRY_LEN);
4734 tmf->tmf_header.rqs_entry_type = RQSTYPE_TSK_MGMT;
4735 tmf->tmf_header.rqs_entry_count = 1;
4736 tmf->tmf_nphdl = lp->handle;
4738 tmf->tmf_timeout = 4;
4739 tmf->tmf_flags = ISP24XX_TMF_TARGET_RESET;
4740 tmf->tmf_tidlo = lp->portid;
4741 tmf->tmf_tidhi = lp->portid >> 16;
4742 tmf->tmf_vpidx = ISP_GET_VPIDX(isp, chan);
4743 isp_put_24xx_tmf(isp, tmf, isp->isp_iocb);
4744 if (isp->isp_dblev & ISP_LOGDEBUG1)
4745 isp_print_bytes(isp, "TMF IOCB request", QENTRY_LEN, isp->isp_iocb);
4746 MEMORYBARRIER(isp, SYNC_IFORDEV, 0, QENTRY_LEN, chan);
4747 fcp->sendmarker = 1;
4749 isp_prt(isp, ISP_LOGALL, "Chan %d Reset N-Port Handle 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
4750 MBSINIT(&mbs, MBOX_EXEC_COMMAND_IOCB_A64, MBLOGALL,
4751 MBCMD_DEFAULT_TIMEOUT + tmf->tmf_timeout * 1000000);
4752 mbs.param[1] = QENTRY_LEN;
4753 mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
4754 mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
4755 mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
4756 mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
4757 isp_mboxcmd(isp, &mbs);
4758 if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
4761 MEMORYBARRIER(isp, SYNC_IFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
4762 if (isp->isp_dblev & ISP_LOGDEBUG1)
4763 isp_print_bytes(isp, "TMF IOCB response", QENTRY_LEN, &((isp24xx_statusreq_t *)isp->isp_iocb)[1]);
4764 sp = (isp24xx_statusreq_t *) local;
4765 isp_get_24xx_response(isp, &((isp24xx_statusreq_t *)isp->isp_iocb)[1], sp);
4766 if (sp->req_completion_status == 0) {
4769 isp_prt(isp, ISP_LOGWARN, "Chan %d reset of target %d returned 0x%x", chan, tgt, sp->req_completion_status);
4771 } else if (IS_FC(isp)) {
4772 if (ISP_CAP_2KLOGIN(isp)) {
4774 mbs.ibits = (1 << 10);
4776 mbs.param[1] = (tgt << 8);
4779 mbs.param[1] = (chan << 15) | (tgt << 8);
4781 MBSINIT(&mbs, MBOX_ABORT_TARGET, MBLOGALL, 0);
4782 mbs.param[2] = 3; /* 'delay', in seconds */
4783 isp_mboxcmd(isp, &mbs);
4784 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4787 isp_prt(isp, ISP_LOGINFO, "Target %d on Bus %d Reset Succeeded", tgt, chan);
4788 ISP_SET_SENDMARKER(isp, chan, 1);
4791 case ISPCTL_ABORT_CMD:
4793 xs = va_arg(ap, XS_T *);
4797 chan = XS_CHANNEL(xs);
4799 handle = isp_find_handle(isp, xs);
4801 isp_prt(isp, ISP_LOGWARN, "cannot find handle for command to abort");
4805 isp24xx_abrt_t local, *ab = &local;
4809 fcp = FCPARAM(isp, chan);
4810 if (tgt < 0 || tgt >= MAX_FC_TARG) {
4811 isp_prt(isp, ISP_LOGWARN, "Chan %d trying to abort bad target %d", chan, tgt);
4814 lp = &fcp->portdb[tgt];
4815 if (lp->is_target == 0 ||
4816 lp->state != FC_PORTDB_STATE_VALID) {
4817 isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
4820 isp_prt(isp, ISP_LOGALL, "Chan %d Abort Cmd for N-Port 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
4821 ISP_MEMZERO(ab, QENTRY_LEN);
4822 ab->abrt_header.rqs_entry_type = RQSTYPE_ABORT_IO;
4823 ab->abrt_header.rqs_entry_count = 1;
4824 ab->abrt_handle = lp->handle;
4825 ab->abrt_cmd_handle = handle;
4826 ab->abrt_tidlo = lp->portid;
4827 ab->abrt_tidhi = lp->portid >> 16;
4828 ab->abrt_vpidx = ISP_GET_VPIDX(isp, chan);
4829 isp_put_24xx_abrt(isp, ab, isp->isp_iocb);
4830 if (isp->isp_dblev & ISP_LOGDEBUG1)
4831 isp_print_bytes(isp, "AB IOCB quest", QENTRY_LEN, isp->isp_iocb);
4832 MEMORYBARRIER(isp, SYNC_IFORDEV, 0, 2 * QENTRY_LEN, chan);
4834 ISP_MEMZERO(&mbs, sizeof (mbs));
4835 MBSINIT(&mbs, MBOX_EXEC_COMMAND_IOCB_A64, MBLOGALL, 5000000);
4836 mbs.param[1] = QENTRY_LEN;
4837 mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
4838 mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
4839 mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
4840 mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
4842 isp_mboxcmd(isp, &mbs);
4843 if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
4846 MEMORYBARRIER(isp, SYNC_IFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
4847 if (isp->isp_dblev & ISP_LOGDEBUG1)
4848 isp_print_bytes(isp, "AB IOCB response", QENTRY_LEN, &((isp24xx_abrt_t *)isp->isp_iocb)[1]);
4849 isp_get_24xx_abrt(isp, &((isp24xx_abrt_t *)isp->isp_iocb)[1], ab);
4850 if (ab->abrt_nphdl == ISP24XX_ABRT_OKAY) {
4853 isp_prt(isp, ISP_LOGWARN, "Chan %d handle %d abort returned 0x%x", chan, tgt, ab->abrt_nphdl);
4855 } else if (IS_FC(isp)) {
4856 if (ISP_CAP_SCCFW(isp)) {
4857 if (ISP_CAP_2KLOGIN(isp)) {
4860 mbs.param[1] = tgt << 8;
4862 mbs.param[6] = XS_LUN(xs);
4864 mbs.param[1] = tgt << 8 | XS_LUN(xs);
4867 mbs.param[1] = (chan << 15) | (tgt << 8) | XS_LUN(xs);
4869 MBSINIT(&mbs, MBOX_ABORT,
4870 MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_ERROR), 0);
4871 mbs.param[2] = handle;
4872 isp_mboxcmd(isp, &mbs);
4873 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4878 case ISPCTL_UPDATE_PARAMS:
4881 chan = va_arg(ap, int);
4883 isp_spi_update(isp, chan);
4886 case ISPCTL_FCLINK_TEST:
4891 chan = va_arg(ap, int);
4892 usdelay = va_arg(ap, int);
4897 return (isp_fclink_test(isp, chan, usdelay));
4901 case ISPCTL_SCAN_FABRIC:
4905 chan = va_arg(ap, int);
4907 return (isp_scan_fabric(isp, chan));
4911 case ISPCTL_SCAN_LOOP:
4915 chan = va_arg(ap, int);
4917 return (isp_scan_loop(isp, chan));
4921 case ISPCTL_PDB_SYNC:
4925 chan = va_arg(ap, int);
4927 return (isp_pdb_sync(isp, chan));
4931 case ISPCTL_SEND_LIP:
4933 if (IS_FC(isp) && !IS_24XX(isp)) {
4934 MBSINIT(&mbs, MBOX_INIT_LIP, MBLOGALL, 0);
4935 if (ISP_CAP_2KLOGIN(isp)) {
4936 mbs.ibits = (1 << 10);
4938 isp_mboxcmd(isp, &mbs);
4939 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
4945 case ISPCTL_GET_PDB:
4949 chan = va_arg(ap, int);
4950 tgt = va_arg(ap, int);
4951 pdb = va_arg(ap, isp_pdb_t *);
4953 return (isp_getpdb(isp, chan, tgt, pdb));
4957 case ISPCTL_GET_NAMES:
4959 uint64_t *wwnn, *wwnp;
4961 chan = va_arg(ap, int);
4962 tgt = va_arg(ap, int);
4963 wwnn = va_arg(ap, uint64_t *);
4964 wwnp = va_arg(ap, uint64_t *);
4966 if (wwnn == NULL && wwnp == NULL) {
4970 *wwnn = isp_get_wwn(isp, chan, tgt, 1);
4971 if (*wwnn == INI_NONE) {
4976 *wwnp = isp_get_wwn(isp, chan, tgt, 0);
4977 if (*wwnp == INI_NONE) {
4983 case ISPCTL_RUN_MBOXCMD:
4986 mbr = va_arg(ap, mbreg_t *);
4988 isp_mboxcmd(isp, mbr);
4997 p = va_arg(ap, isp_plcmd_t *);
5000 if ((p->flags & PLOGX_FLG_CMD_MASK) != PLOGX_FLG_CMD_PLOGI || (p->handle != NIL_HANDLE)) {
5001 return (isp_plogx(isp, p->channel, p->handle, p->portid, p->flags));
5004 isp_next_handle(isp, &p->handle);
5005 r = isp_plogx(isp, p->channel, p->handle, p->portid, p->flags);
5006 if ((r & 0xffff) == MBOX_PORT_ID_USED) {
5007 p->handle = r >> 16;
5011 } while ((r & 0xffff) == MBOX_LOOP_ID_USED);
5014 case ISPCTL_CHANGE_ROLE:
5019 chan = va_arg(ap, int);
5020 role = va_arg(ap, int);
5022 r = isp_fc_change_role(isp, chan, role);
5027 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
5035 * Interrupt Service Routine(s).
5037 * External (OS) framework has done the appropriate locking,
5038 * and the locking will be held throughout this function.
5041 #ifdef ISP_TARGET_MODE
5043 isp_intr_atioq(ispsoftc_t *isp)
5045 uint8_t qe[QENTRY_LEN];
5048 uint32_t iptr, optr, oop;
5050 iptr = ISP_READ(isp, BIU2400_ATIO_RSPINP);
5051 optr = isp->isp_atioodx;
5052 while (optr != iptr) {
5054 MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN, -1);
5055 addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
5056 isp_get_hdr(isp, addr, (isphdr_t *)qe);
5057 hp = (isphdr_t *)qe;
5058 switch (hp->rqs_entry_type) {
5059 case RQSTYPE_NOTIFY:
5061 (void) isp_target_notify(isp, addr, &oop);
5064 isp_print_qentry(isp, "?ATIOQ entry?", oop, addr);
5067 optr = ISP_NXT_QENTRY(oop, RESULT_QUEUE_LEN(isp));
5069 if (isp->isp_atioodx != optr) {
5070 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, optr);
5071 isp->isp_atioodx = optr;
5077 isp_intr_async(ispsoftc_t *isp, uint16_t event)
5081 isp_parse_async_fc(isp, event);
5083 isp_parse_async(isp, event);
5087 isp_intr_mbox(ispsoftc_t *isp, uint16_t mbox0)
5091 if (!isp->isp_mboxbsy) {
5092 isp_prt(isp, ISP_LOGWARN, "mailbox 0x%x with no waiters", mbox0);
5095 obits = isp->isp_obits;
5096 isp->isp_mboxtmp[0] = mbox0;
5097 for (i = 1; i < ISP_NMBOX(isp); i++) {
5098 if ((obits & (1 << i)) == 0)
5100 isp->isp_mboxtmp[i] = ISP_READ(isp, MBOX_OFF(i));
5102 MBOX_NOTIFY_COMPLETE(isp);
5106 isp_intr_respq(ispsoftc_t *isp)
5109 uint8_t qe[QENTRY_LEN];
5110 ispstatusreq_t *sp = (ispstatusreq_t *)qe;
5111 isp24xx_statusreq_t *sp2 = (isp24xx_statusreq_t *)qe;
5113 uint8_t *resp, *snsp;
5114 int buddaboom, completion_status, cont = 0, etype, i;
5115 int req_status_flags, req_state_flags, scsi_status;
5116 uint32_t iptr, junk, cptr, optr, rlen, slen, sptr, totslen, resid;
5119 * We can't be getting this now.
5121 if (isp->isp_state != ISP_RUNSTATE) {
5122 isp_prt(isp, ISP_LOGINFO, "respq interrupt when not ready");
5126 iptr = ISP_READ(isp, isp->isp_respinrp);
5127 /* Debounce the 2300 if revision less than 2. */
5128 if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
5131 iptr = ISP_READ(isp, isp->isp_respinrp);
5132 } while (junk != iptr);
5134 isp->isp_residx = iptr;
5136 optr = isp->isp_resodx;
5137 while (optr != iptr) {
5139 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, cptr);
5140 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
5143 * Synchronize our view of this response queue entry.
5145 MEMORYBARRIER(isp, SYNC_RESULT, cptr, QENTRY_LEN, -1);
5146 if (isp->isp_dblev & ISP_LOGDEBUG1)
5147 isp_print_qentry(isp, "Response Queue Entry", cptr, hp);
5148 isp_get_hdr(isp, hp, &sp->req_header);
5149 etype = sp->req_header.rqs_entry_type;
5151 /* We expected Status Continuation, but got different IOCB. */
5152 if (cont > 0 && etype != RQSTYPE_STATUS_CONT) {
5157 if (IS_24XX(isp) && etype == RQSTYPE_RESPONSE) {
5158 isp_get_24xx_response(isp, (isp24xx_statusreq_t *)hp, sp2);
5159 scsi_status = sp2->req_scsi_status;
5160 completion_status = sp2->req_completion_status;
5161 req_status_flags = 0;
5162 if ((scsi_status & 0xff) != 0)
5163 req_state_flags = RQSF_GOT_STATUS;
5165 req_state_flags = 0;
5166 resid = sp2->req_resid;
5167 } else if (etype == RQSTYPE_RESPONSE) {
5168 isp_get_response(isp, (ispstatusreq_t *) hp, sp);
5169 scsi_status = sp->req_scsi_status;
5170 completion_status = sp->req_completion_status;
5171 req_status_flags = sp->req_status_flags;
5172 req_state_flags = sp->req_state_flags;
5173 resid = sp->req_resid;
5174 } else if (etype == RQSTYPE_RIO1) {
5175 isp_rio1_t *rio = (isp_rio1_t *) qe;
5176 isp_get_rio1(isp, (isp_rio1_t *) hp, rio);
5177 for (i = 0; i < rio->req_header.rqs_seqno; i++) {
5178 isp_fastpost_complete(isp, rio->req_handles[i]);
5180 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5182 } else if (etype == RQSTYPE_RIO2) {
5183 isp_prt(isp, ISP_LOGERR, "dropping RIO2 response");
5184 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5186 } else if (etype == RQSTYPE_STATUS_CONT) {
5187 ispstatus_cont_t *scp = (ispstatus_cont_t *)qe;
5188 isp_get_cont_response(isp, (ispstatus_cont_t *)hp, scp);
5190 i = min(cont, sizeof(scp->req_sense_data));
5191 XS_SENSE_APPEND(cont_xs, scp->req_sense_data, i);
5196 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
5197 "Expecting Status Continuations for %u bytes",
5201 isp_prt(isp, ISP_LOG_WARN1, "Ignored Continuation Response");
5203 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5205 } else if (isp_handle_other_response(isp, etype, hp, &cptr)) {
5206 /* More then one IOCB could be consumed. */
5207 while (sptr != cptr) {
5208 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5209 sptr = ISP_NXT_QENTRY(sptr, RESULT_QUEUE_LEN(isp));
5210 hp = (isphdr_t *)ISP_QUEUE_ENTRY(isp->isp_result, sptr);
5212 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5213 optr = ISP_NXT_QENTRY(cptr, RESULT_QUEUE_LEN(isp));
5216 /* We don't know what was this -- log and skip. */
5217 isp_prt(isp, ISP_LOGERR, notresp, etype, cptr, optr);
5218 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5223 if (sp->req_header.rqs_flags & RQSFLAG_MASK) {
5224 if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
5225 isp_print_qentry(isp, "unexpected continuation segment",
5229 if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
5230 isp_prt(isp, ISP_LOG_WARN1, "internal queues full");
5232 * We'll synthesize a QUEUE FULL message below.
5235 if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
5236 isp_print_qentry(isp, "bad header flag",
5240 if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
5241 isp_print_qentry(isp, "bad request packet",
5245 if (sp->req_header.rqs_flags & RQSFLAG_BADCOUNT) {
5246 isp_print_qentry(isp, "invalid entry count",
5250 if (sp->req_header.rqs_flags & RQSFLAG_BADORDER) {
5251 isp_print_qentry(isp, "invalid IOCB ordering",
5257 xs = isp_find_xs(isp, sp->req_handle);
5259 uint8_t ts = completion_status & 0xff;
5261 * Only whine if this isn't the expected fallout of
5262 * aborting the command or resetting the target.
5264 if (etype != RQSTYPE_RESPONSE) {
5265 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (type 0x%x)", sp->req_handle, etype);
5266 } else if (ts != RQCS_ABORTED && ts != RQCS_RESET_OCCURRED) {
5267 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (status 0x%x)", sp->req_handle, ts);
5269 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5272 if (req_status_flags & RQSTF_BUS_RESET) {
5273 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%jx bus was reset",
5274 XS_CHANNEL(xs), XS_TGT(xs), (uintmax_t)XS_LUN(xs));
5275 XS_SETERR(xs, HBA_BUSRESET);
5276 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
5279 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%jx buddaboom",
5280 XS_CHANNEL(xs), XS_TGT(xs), (uintmax_t)XS_LUN(xs));
5281 XS_SETERR(xs, HBA_BOTCH);
5285 rlen = slen = totslen = 0;
5286 if (IS_24XX(isp) && (scsi_status & (RQCS_RV|RQCS_SV)) != 0) {
5287 resp = sp2->req_rsp_sense;
5288 rlen = sp2->req_response_len;
5289 } else if (IS_FC(isp) && (scsi_status & RQCS_RV) != 0) {
5290 resp = sp->req_response;
5291 rlen = sp->req_response_len;
5293 if (IS_FC(isp) && (scsi_status & RQCS_SV) != 0) {
5295 * Fibre Channel F/W doesn't say we got status
5296 * if there's Sense Data instead. I guess they
5297 * think it goes w/o saying.
5299 req_state_flags |= RQSF_GOT_STATUS|RQSF_GOT_SENSE;
5301 snsp = sp2->req_rsp_sense;
5303 totslen = sp2->req_sense_len;
5304 slen = sizeof(sp2->req_rsp_sense) - rlen;
5306 snsp = sp->req_sense_data;
5307 totslen = sp->req_sense_len;
5308 slen = sizeof(sp->req_sense_data);
5310 } else if (IS_SCSI(isp) && (req_state_flags & RQSF_GOT_SENSE)) {
5311 snsp = sp->req_sense_data;
5312 totslen = sp->req_sense_len;
5313 slen = sizeof (sp->req_sense_data);
5317 if (req_state_flags & RQSF_GOT_STATUS)
5318 *XS_STSP(xs) = scsi_status & 0xff;
5320 if (rlen >= 4 && resp[FCP_RSPNS_CODE_OFFSET] != 0) {
5323 const char *rnames[10] = {
5324 "Task Management function complete",
5325 "FCP_DATA length different than FCP_BURST_LEN",
5326 "FCP_CMND fields invalid",
5327 "FCP_DATA parameter mismatch with FCP_DATA_RO",
5328 "Task Management function rejected",
5329 "Task Management function failed",
5332 "Task Management function succeeded",
5333 "Task Management function incorrect logical unit number",
5335 uint8_t code = resp[FCP_RSPNS_CODE_OFFSET];
5336 if (code >= 10 || rnames[code] == NULL) {
5337 ISP_SNPRINTF(lb, sizeof(lb),
5338 "Unknown FCP Response Code 0x%x", code);
5343 isp_xs_prt(isp, xs, ISP_LOGWARN,
5344 "FCP RESPONSE, LENGTH %u: %s CDB0=0x%02x",
5345 rlen, ptr, XS_CDBP(xs)[0] & 0xff);
5346 if (code != 0 && code != 8)
5347 XS_SETERR(xs, HBA_BOTCH);
5350 isp_parse_status_24xx(isp, sp2, xs, &resid);
5352 isp_parse_status(isp, sp, xs, &resid);
5353 if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
5354 (*XS_STSP(xs) == SCSI_BUSY))
5355 XS_SETERR(xs, HBA_TGTBSY);
5357 XS_SET_RESID(xs, resid);
5359 * A new synchronous rate was negotiated for
5360 * this target. Mark state such that we'll go
5361 * look up that which has changed later.
5363 if (req_status_flags & RQSTF_NEGOTIATION) {
5365 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
5366 sdp->isp_devparam[t].dev_refresh = 1;
5370 if (req_status_flags & RQSF_XFER_COMPLETE) {
5371 XS_SET_RESID(xs, 0);
5372 } else if (scsi_status & RQCS_RESID) {
5373 XS_SET_RESID(xs, resid);
5375 XS_SET_RESID(xs, 0);
5379 XS_SAVE_SENSE(xs, snsp, slen);
5380 if (totslen > slen) {
5381 cont = totslen - slen;
5383 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
5384 "Expecting Status Continuations for %u bytes",
5388 isp_prt(isp, ISP_LOGDEBUG2, "asked for %lu got raw resid %lu settled for %lu",
5389 (u_long)XS_XFRLEN(xs), (u_long)resid, (u_long)XS_GET_RESID(xs));
5392 ISP_DMAFREE(isp, xs, sp->req_handle);
5393 isp_destroy_handle(isp, sp->req_handle);
5395 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5397 /* Complete command if we expect no Status Continuations. */
5402 /* We haven't received all Status Continuations, but that is it. */
5406 /* If we processed any IOCBs, let ISP know about it. */
5407 if (optr != isp->isp_resodx) {
5408 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5409 isp->isp_resodx = optr;
5414 * Parse an ASYNC mailbox complete
5417 isp_parse_async(ispsoftc_t *isp, uint16_t mbox)
5419 uint32_t h1 = 0, h2 = 0;
5423 * Pick up the channel, but not if this is a ASYNC_RIO32_2,
5424 * where Mailboxes 6/7 have the second handle.
5426 if (mbox != ASYNC_RIO32_2) {
5427 if (IS_DUALBUS(isp)) {
5428 chan = ISP_READ(isp, OUTMAILBOX6);
5431 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5434 case ASYNC_BUS_RESET:
5435 ISP_SET_SENDMARKER(isp, chan, 1);
5436 #ifdef ISP_TARGET_MODE
5437 isp_target_async(isp, chan, mbox);
5439 isp_async(isp, ISPASYNC_BUS_RESET, chan);
5441 case ASYNC_SYSTEM_ERROR:
5442 isp->isp_state = ISP_CRASHED;
5444 * Were we waiting for a mailbox command to complete?
5445 * If so, it's dead, so wake up the waiter.
5447 if (isp->isp_mboxbsy) {
5449 isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5450 MBOX_NOTIFY_COMPLETE(isp);
5453 * It's up to the handler for isp_async to reinit stuff and
5454 * restart the firmware
5456 isp_async(isp, ISPASYNC_FW_CRASH);
5459 case ASYNC_RQS_XFER_ERR:
5460 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5463 case ASYNC_RSP_XFER_ERR:
5464 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5469 * We've just been notified that the Queue has woken up.
5470 * We don't need to be chatty about this- just unlatch things
5473 mbox = ISP_READ(isp, isp->isp_rqstoutrp);
5476 case ASYNC_TIMEOUT_RESET:
5477 isp_prt(isp, ISP_LOGWARN, "timeout initiated SCSI bus reset of chan %d", chan);
5478 ISP_SET_SENDMARKER(isp, chan, 1);
5479 #ifdef ISP_TARGET_MODE
5480 isp_target_async(isp, chan, mbox);
5484 case ASYNC_DEVICE_RESET:
5485 isp_prt(isp, ISP_LOGINFO, "device reset on chan %d", chan);
5486 ISP_SET_SENDMARKER(isp, chan, 1);
5487 #ifdef ISP_TARGET_MODE
5488 isp_target_async(isp, chan, mbox);
5492 case ASYNC_EXTMSG_UNDERRUN:
5493 isp_prt(isp, ISP_LOGWARN, "extended message underrun");
5496 case ASYNC_SCAM_INT:
5497 isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
5500 case ASYNC_HUNG_SCSI:
5501 isp_prt(isp, ISP_LOGERR, "stalled SCSI Bus after DATA Overrun");
5502 /* XXX: Need to issue SCSI reset at this point */
5505 case ASYNC_KILLED_BUS:
5506 isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
5509 case ASYNC_BUS_TRANSIT:
5510 mbox = ISP_READ(isp, OUTMAILBOX2);
5511 switch (mbox & SXP_PINS_MODE_MASK) {
5512 case SXP_PINS_LVD_MODE:
5513 isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
5514 SDPARAM(isp, chan)->isp_diffmode = 0;
5515 SDPARAM(isp, chan)->isp_ultramode = 0;
5516 SDPARAM(isp, chan)->isp_lvdmode = 1;
5518 case SXP_PINS_HVD_MODE:
5519 isp_prt(isp, ISP_LOGINFO,
5520 "Transition to Differential mode");
5521 SDPARAM(isp, chan)->isp_diffmode = 1;
5522 SDPARAM(isp, chan)->isp_ultramode = 0;
5523 SDPARAM(isp, chan)->isp_lvdmode = 0;
5525 case SXP_PINS_SE_MODE:
5526 isp_prt(isp, ISP_LOGINFO,
5527 "Transition to Single Ended mode");
5528 SDPARAM(isp, chan)->isp_diffmode = 0;
5529 SDPARAM(isp, chan)->isp_ultramode = 1;
5530 SDPARAM(isp, chan)->isp_lvdmode = 0;
5533 isp_prt(isp, ISP_LOGWARN,
5534 "Transition to Unknown Mode 0x%x", mbox);
5538 * XXX: Set up to renegotiate again!
5540 /* Can only be for a 1080... */
5541 ISP_SET_SENDMARKER(isp, chan, 1);
5544 case ASYNC_CMD_CMPLT:
5546 if (!IS_ULTRA3(isp)) {
5547 isp_prt(isp, ISP_LOGERR, "unexpected fast posting completion");
5551 h1 = (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1);
5555 h1 = (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1);
5556 h2 = (ISP_READ(isp, OUTMAILBOX7) << 16) | ISP_READ(isp, OUTMAILBOX6);
5564 isp_prt(isp, ISP_LOGERR, "unexpected 16 bit RIO handle");
5567 isp_prt(isp, ISP_LOGWARN, "%s: unhandled async code 0x%x", __func__, mbox);
5572 isp_prt(isp, ISP_LOGDEBUG3, "fast post/rio completion of 0x%08x", h1);
5573 isp_fastpost_complete(isp, h1);
5575 isp_prt(isp, ISP_LOGDEBUG3, "fast post/rio completion of 0x%08x", h2);
5576 isp_fastpost_complete(isp, h2);
5582 isp_parse_async_fc(ispsoftc_t *isp, uint16_t mbox)
5587 if (IS_DUALBUS(isp)) {
5588 chan = ISP_READ(isp, OUTMAILBOX6);
5592 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5595 case ASYNC_SYSTEM_ERROR:
5596 isp->isp_state = ISP_CRASHED;
5597 FCPARAM(isp, chan)->isp_loopstate = LOOP_NIL;
5598 isp_change_fw_state(isp, chan, FW_CONFIG_WAIT);
5600 * Were we waiting for a mailbox command to complete?
5601 * If so, it's dead, so wake up the waiter.
5603 if (isp->isp_mboxbsy) {
5605 isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5606 MBOX_NOTIFY_COMPLETE(isp);
5609 * It's up to the handler for isp_async to reinit stuff and
5610 * restart the firmware
5612 isp_async(isp, ISPASYNC_FW_CRASH);
5615 case ASYNC_RQS_XFER_ERR:
5616 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5619 case ASYNC_RSP_XFER_ERR:
5620 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5624 #ifdef ISP_TARGET_MODE
5626 isp_prt(isp, ISP_LOGERR, "ATIO Queue Transfer Error");
5630 isp_prt(isp, ISP_LOGERR, "%s: unexpected ASYNC_QWAKEUP code", __func__);
5633 case ASYNC_CMD_CMPLT:
5634 isp_fastpost_complete(isp, (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1));
5637 case ASYNC_RIOZIO_STALL:
5638 isp_intr_respq(isp);
5641 case ASYNC_CTIO_DONE:
5642 #ifdef ISP_TARGET_MODE
5643 isp_target_async(isp, (ISP_READ(isp, OUTMAILBOX2) << 16) |
5644 ISP_READ(isp, OUTMAILBOX1), mbox);
5646 isp_prt(isp, ISP_LOGWARN, "unexpected ASYNC CTIO done");
5649 case ASYNC_LIP_ERROR:
5650 case ASYNC_LIP_NOS_OLS_RECV:
5651 case ASYNC_LIP_OCCURRED:
5654 * These are broadcast events that have to be sent across
5655 * all active channels.
5657 for (chan = 0; chan < isp->isp_nchan; chan++) {
5658 fcp = FCPARAM(isp, chan);
5659 int topo = fcp->isp_topo;
5661 if (fcp->role == ISP_ROLE_NONE)
5663 if (fcp->isp_loopstate > LOOP_HAVE_LINK)
5664 fcp->isp_loopstate = LOOP_HAVE_LINK;
5665 ISP_SET_SENDMARKER(isp, chan, 1);
5666 isp_async(isp, ISPASYNC_LIP, chan);
5667 #ifdef ISP_TARGET_MODE
5668 isp_target_async(isp, chan, mbox);
5671 * We've had problems with data corruption occurring on
5672 * commands that complete (with no apparent error) after
5673 * we receive a LIP. This has been observed mostly on
5674 * Local Loop topologies. To be safe, let's just mark
5675 * all active initiator commands as dead.
5677 if (topo == TOPO_NL_PORT || topo == TOPO_FL_PORT) {
5679 for (i = j = 0; i < isp->isp_maxcmds; i++) {
5683 hdp = &isp->isp_xflist[i];
5684 if (ISP_H2HT(hdp->handle) != ISP_HANDLE_INITIATOR) {
5688 if (XS_CHANNEL(xs) != chan) {
5692 isp_prt(isp, ISP_LOG_WARN1,
5693 "%d.%d.%jx bus reset set at %s:%u",
5694 XS_CHANNEL(xs), XS_TGT(xs),
5695 (uintmax_t)XS_LUN(xs),
5696 __func__, __LINE__);
5697 XS_SETERR(xs, HBA_BUSRESET);
5700 isp_prt(isp, ISP_LOGERR, lipd, chan, j);
5708 * This is a broadcast event that has to be sent across
5709 * all active channels.
5711 for (chan = 0; chan < isp->isp_nchan; chan++) {
5712 fcp = FCPARAM(isp, chan);
5713 if (fcp->role == ISP_ROLE_NONE)
5715 fcp->isp_linkstate = 1;
5716 if (fcp->isp_loopstate < LOOP_HAVE_LINK)
5717 fcp->isp_loopstate = LOOP_HAVE_LINK;
5718 ISP_SET_SENDMARKER(isp, chan, 1);
5719 isp_async(isp, ISPASYNC_LOOP_UP, chan);
5720 #ifdef ISP_TARGET_MODE
5721 isp_target_async(isp, chan, mbox);
5726 case ASYNC_LOOP_DOWN:
5728 * This is a broadcast event that has to be sent across
5729 * all active channels.
5731 for (chan = 0; chan < isp->isp_nchan; chan++) {
5732 fcp = FCPARAM(isp, chan);
5733 if (fcp->role == ISP_ROLE_NONE)
5735 ISP_SET_SENDMARKER(isp, chan, 1);
5736 fcp->isp_linkstate = 0;
5737 fcp->isp_loopstate = LOOP_NIL;
5738 isp_async(isp, ISPASYNC_LOOP_DOWN, chan);
5739 #ifdef ISP_TARGET_MODE
5740 isp_target_async(isp, chan, mbox);
5745 case ASYNC_LOOP_RESET:
5747 * This is a broadcast event that has to be sent across
5748 * all active channels.
5750 for (chan = 0; chan < isp->isp_nchan; chan++) {
5751 fcp = FCPARAM(isp, chan);
5752 if (fcp->role == ISP_ROLE_NONE)
5754 ISP_SET_SENDMARKER(isp, chan, 1);
5755 if (fcp->isp_loopstate > LOOP_HAVE_LINK)
5756 fcp->isp_loopstate = LOOP_HAVE_LINK;
5757 isp_async(isp, ISPASYNC_LOOP_RESET, chan);
5758 #ifdef ISP_TARGET_MODE
5759 isp_target_async(isp, chan, mbox);
5764 case ASYNC_PDB_CHANGED:
5766 int echan, nphdl, nlstate, reason;
5768 if (IS_23XX(isp) || IS_24XX(isp)) {
5769 nphdl = ISP_READ(isp, OUTMAILBOX1);
5770 nlstate = ISP_READ(isp, OUTMAILBOX2);
5772 nphdl = nlstate = 0xffff;
5775 reason = ISP_READ(isp, OUTMAILBOX3) >> 8;
5778 if (ISP_CAP_MULTI_ID(isp)) {
5779 chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
5780 if (chan == 0xff || nphdl == NIL_HANDLE) {
5782 echan = isp->isp_nchan - 1;
5783 } else if (chan >= isp->isp_nchan) {
5791 for (; chan <= echan; chan++) {
5792 fcp = FCPARAM(isp, chan);
5793 if (fcp->role == ISP_ROLE_NONE)
5795 if (fcp->isp_loopstate > LOOP_LTEST_DONE) {
5796 if (nphdl != NIL_HANDLE &&
5797 nphdl == fcp->isp_login_hdl &&
5798 reason == PDB24XX_AE_OPN_2)
5800 fcp->isp_loopstate = LOOP_LTEST_DONE;
5801 } else if (fcp->isp_loopstate < LOOP_HAVE_LINK)
5802 fcp->isp_loopstate = LOOP_HAVE_LINK;
5803 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
5804 ISPASYNC_CHANGE_PDB, nphdl, nlstate, reason);
5808 case ASYNC_CHANGE_NOTIFY:
5812 portid = ((ISP_READ(isp, OUTMAILBOX1) & 0xff) << 16) |
5813 ISP_READ(isp, OUTMAILBOX2);
5814 if (ISP_CAP_MULTI_ID(isp)) {
5815 chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
5816 if (chan >= isp->isp_nchan)
5821 fcp = FCPARAM(isp, chan);
5822 if (fcp->role == ISP_ROLE_NONE)
5824 if (fcp->isp_loopstate > LOOP_LTEST_DONE)
5825 fcp->isp_loopstate = LOOP_LTEST_DONE;
5826 else if (fcp->isp_loopstate < LOOP_HAVE_LINK)
5827 fcp->isp_loopstate = LOOP_HAVE_LINK;
5828 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
5829 ISPASYNC_CHANGE_SNS, portid);
5832 case ASYNC_ERR_LOGGING_DISABLED:
5833 isp_prt(isp, ISP_LOGWARN, "Error logging disabled (reason 0x%x)",
5834 ISP_READ(isp, OUTMAILBOX1));
5836 case ASYNC_CONNMODE:
5838 * This only applies to 2100 amd 2200 cards
5840 if (!IS_2200(isp) && !IS_2100(isp)) {
5841 isp_prt(isp, ISP_LOGWARN, "bad card for ASYNC_CONNMODE event");
5845 mbox = ISP_READ(isp, OUTMAILBOX1);
5848 isp_prt(isp, ISP_LOGINFO,
5849 "Point-to-Point -> Loop mode");
5852 isp_prt(isp, ISP_LOGINFO,
5853 "Loop -> Point-to-Point mode");
5855 case ISP_CONN_BADLIP:
5856 isp_prt(isp, ISP_LOGWARN,
5857 "Point-to-Point -> Loop mode (BAD LIP)");
5859 case ISP_CONN_FATAL:
5860 isp->isp_state = ISP_CRASHED;
5861 isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
5862 isp_async(isp, ISPASYNC_FW_CRASH);
5864 case ISP_CONN_LOOPBACK:
5865 isp_prt(isp, ISP_LOGWARN,
5866 "Looped Back in Point-to-Point mode");
5869 isp_prt(isp, ISP_LOGWARN,
5870 "Unknown connection mode (0x%x)", mbox);
5873 ISP_SET_SENDMARKER(isp, chan, 1);
5874 FCPARAM(isp, chan)->isp_loopstate = LOOP_HAVE_LINK;
5875 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan, ISPASYNC_CHANGE_OTHER);
5877 case ASYNC_P2P_INIT_ERR:
5878 isp_prt(isp, ISP_LOGWARN, "P2P init error (reason 0x%x)",
5879 ISP_READ(isp, OUTMAILBOX1));
5883 isp_prt(isp, ISP_LOGWARN, "Receive Error");
5885 isp_prt(isp, ISP_LOGWARN, "unexpected ASYNC_RCV_ERR");
5888 case ASYNC_RJT_SENT: /* same as ASYNC_QFULL_SENT */
5890 isp_prt(isp, ISP_LOGTDEBUG0, "LS_RJT sent");
5893 isp_prt(isp, ISP_LOGTDEBUG0, "QFULL sent");
5896 case ASYNC_FW_RESTART_COMPLETE:
5897 isp_prt(isp, ISP_LOGDEBUG0, "FW restart complete");
5899 case ASYNC_TEMPERATURE_ALERT:
5900 isp_prt(isp, ISP_LOGERR, "Temperature alert (subcode 0x%x)",
5901 ISP_READ(isp, OUTMAILBOX1));
5903 case ASYNC_AUTOLOAD_FW_COMPLETE:
5904 isp_prt(isp, ISP_LOGDEBUG0, "Autoload FW init complete");
5906 case ASYNC_AUTOLOAD_FW_FAILURE:
5907 isp_prt(isp, ISP_LOGERR, "Autoload FW init failure");
5910 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
5916 * Handle other response entries. A pointer to the request queue output
5917 * index is here in case we want to eat several entries at once, although
5918 * this is not used currently.
5922 isp_handle_other_response(ispsoftc_t *isp, int type, isphdr_t *hp, uint32_t *optrp)
5926 uint32_t hdl, portid;
5930 case RQSTYPE_MARKER:
5931 isp_prt(isp, ISP_LOG_WARN1, "Marker Response");
5933 case RQSTYPE_RPT_ID_ACQ:
5934 isp_get_ridacq(isp, (isp_ridacq_t *)hp, &rid);
5935 portid = (uint32_t)rid.ridacq_vp_port_hi << 16 |
5936 rid.ridacq_vp_port_lo;
5937 if (rid.ridacq_format == 0) {
5938 for (chan = 0; chan < isp->isp_nchan; chan++) {
5939 fcparam *fcp = FCPARAM(isp, chan);
5940 if (fcp->role == ISP_ROLE_NONE)
5942 c = (chan == 0) ? 127 : (chan - 1);
5943 if (rid.ridacq_map[c / 16] & (1 << (c % 16)) ||
5945 fcp->isp_loopstate = LOOP_HAVE_LINK;
5946 isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
5947 chan, ISPASYNC_CHANGE_OTHER);
5949 fcp->isp_loopstate = LOOP_NIL;
5950 isp_async(isp, ISPASYNC_LOOP_DOWN,
5955 fcparam *fcp = FCPARAM(isp, rid.ridacq_vp_index);
5956 if (rid.ridacq_vp_status == RIDACQ_STS_COMPLETE ||
5957 rid.ridacq_vp_status == RIDACQ_STS_CHANGED) {
5958 fcp->isp_topo = (rid.ridacq_map[0] >> 9) & 0x7;
5959 fcp->isp_portid = portid;
5960 fcp->isp_loopstate = LOOP_HAVE_ADDR;
5961 isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
5962 rid.ridacq_vp_index, ISPASYNC_CHANGE_OTHER);
5964 fcp->isp_loopstate = LOOP_NIL;
5965 isp_async(isp, ISPASYNC_LOOP_DOWN,
5966 rid.ridacq_vp_index);
5970 case RQSTYPE_CT_PASSTHRU:
5971 case RQSTYPE_VP_MODIFY:
5972 case RQSTYPE_VP_CTRL:
5974 ISP_IOXGET_32(isp, (uint32_t *)(hp + 1), hdl);
5975 ptr = isp_find_xs(isp, hdl);
5977 isp_destroy_handle(isp, hdl);
5978 memcpy(ptr, hp, QENTRY_LEN);
5984 case RQSTYPE_NOTIFY:
5985 case RQSTYPE_NOTIFY_ACK:
5991 case RQSTYPE_ABTS_RCVD:
5992 case RQSTYPE_ABTS_RSP:
5993 #ifdef ISP_TARGET_MODE
5994 return (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp));
5997 case RQSTYPE_REQUEST:
6004 isp_parse_status(ispsoftc_t *isp, ispstatusreq_t *sp, XS_T *xs, uint32_t *rp)
6006 switch (sp->req_completion_status & 0xff) {
6009 XS_SETERR(xs, HBA_NOERROR);
6013 case RQCS_INCOMPLETE:
6014 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
6015 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Selection Timeout @ %s:%d", __func__, __LINE__);
6017 XS_SETERR(xs, HBA_SELTIMEOUT);
6018 *rp = XS_XFRLEN(xs);
6022 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Incomplete, state 0x%x", sp->req_state_flags);
6025 case RQCS_DMA_ERROR:
6026 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA Error");
6027 *rp = XS_XFRLEN(xs);
6030 case RQCS_TRANSPORT_ERROR:
6033 ISP_SNPRINTF(buf, sizeof (buf), "states=>");
6034 if (sp->req_state_flags & RQSF_GOT_BUS) {
6035 ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_BUS", buf);
6037 if (sp->req_state_flags & RQSF_GOT_TARGET) {
6038 ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_TGT", buf);
6040 if (sp->req_state_flags & RQSF_SENT_CDB) {
6041 ISP_SNPRINTF(buf, sizeof (buf), "%s SENT_CDB", buf);
6043 if (sp->req_state_flags & RQSF_XFRD_DATA) {
6044 ISP_SNPRINTF(buf, sizeof (buf), "%s XFRD_DATA", buf);
6046 if (sp->req_state_flags & RQSF_GOT_STATUS) {
6047 ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_STS", buf);
6049 if (sp->req_state_flags & RQSF_GOT_SENSE) {
6050 ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_SNS", buf);
6052 if (sp->req_state_flags & RQSF_XFER_COMPLETE) {
6053 ISP_SNPRINTF(buf, sizeof (buf), "%s XFR_CMPLT", buf);
6055 ISP_SNPRINTF(buf, sizeof (buf), "%s\nstatus=>", buf);
6056 if (sp->req_status_flags & RQSTF_DISCONNECT) {
6057 ISP_SNPRINTF(buf, sizeof (buf), "%s Disconnect", buf);
6059 if (sp->req_status_flags & RQSTF_SYNCHRONOUS) {
6060 ISP_SNPRINTF(buf, sizeof (buf), "%s Sync_xfr", buf);
6062 if (sp->req_status_flags & RQSTF_PARITY_ERROR) {
6063 ISP_SNPRINTF(buf, sizeof (buf), "%s Parity", buf);
6065 if (sp->req_status_flags & RQSTF_BUS_RESET) {
6066 ISP_SNPRINTF(buf, sizeof (buf), "%s Bus_Reset", buf);
6068 if (sp->req_status_flags & RQSTF_DEVICE_RESET) {
6069 ISP_SNPRINTF(buf, sizeof (buf), "%s Device_Reset", buf);
6071 if (sp->req_status_flags & RQSTF_ABORTED) {
6072 ISP_SNPRINTF(buf, sizeof (buf), "%s Aborted", buf);
6074 if (sp->req_status_flags & RQSTF_TIMEOUT) {
6075 ISP_SNPRINTF(buf, sizeof (buf), "%s Timeout", buf);
6077 if (sp->req_status_flags & RQSTF_NEGOTIATION) {
6078 ISP_SNPRINTF(buf, sizeof (buf), "%s Negotiation", buf);
6080 isp_xs_prt(isp, xs, ISP_LOGERR, "Transport Error: %s", buf);
6081 *rp = XS_XFRLEN(xs);
6084 case RQCS_RESET_OCCURRED:
6087 isp_xs_prt(isp, xs, ISP_LOGWARN, "Bus Reset destroyed command");
6088 for (chan = 0; chan < isp->isp_nchan; chan++) {
6089 FCPARAM(isp, chan)->sendmarker = 1;
6092 XS_SETERR(xs, HBA_BUSRESET);
6094 *rp = XS_XFRLEN(xs);
6098 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
6099 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
6101 XS_SETERR(xs, HBA_ABORTED);
6106 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command timed out");
6108 * XXX: Check to see if we logged out of the device.
6111 XS_SETERR(xs, HBA_CMDTIMEOUT);
6115 case RQCS_DATA_OVERRUN:
6116 XS_SET_RESID(xs, sp->req_resid);
6117 isp_xs_prt(isp, xs, ISP_LOGERR, "data overrun (%ld)", (long) XS_GET_RESID(xs));
6119 XS_SETERR(xs, HBA_DATAOVR);
6123 case RQCS_COMMAND_OVERRUN:
6124 isp_xs_prt(isp, xs, ISP_LOGERR, "command overrun");
6127 case RQCS_STATUS_OVERRUN:
6128 isp_xs_prt(isp, xs, ISP_LOGERR, "status overrun");
6131 case RQCS_BAD_MESSAGE:
6132 isp_xs_prt(isp, xs, ISP_LOGERR, "msg not COMMAND COMPLETE after status");
6135 case RQCS_NO_MESSAGE_OUT:
6136 isp_xs_prt(isp, xs, ISP_LOGERR, "No MESSAGE OUT phase after selection");
6139 case RQCS_EXT_ID_FAILED:
6140 isp_xs_prt(isp, xs, ISP_LOGERR, "EXTENDED IDENTIFY failed");
6143 case RQCS_IDE_MSG_FAILED:
6144 isp_xs_prt(isp, xs, ISP_LOGERR, "INITIATOR DETECTED ERROR rejected");
6147 case RQCS_ABORT_MSG_FAILED:
6148 isp_xs_prt(isp, xs, ISP_LOGERR, "ABORT OPERATION rejected");
6151 case RQCS_REJECT_MSG_FAILED:
6152 isp_xs_prt(isp, xs, ISP_LOGERR, "MESSAGE REJECT rejected");
6155 case RQCS_NOP_MSG_FAILED:
6156 isp_xs_prt(isp, xs, ISP_LOGERR, "NOP rejected");
6159 case RQCS_PARITY_ERROR_MSG_FAILED:
6160 isp_xs_prt(isp, xs, ISP_LOGERR, "MESSAGE PARITY ERROR rejected");
6163 case RQCS_DEVICE_RESET_MSG_FAILED:
6164 isp_xs_prt(isp, xs, ISP_LOGWARN, "BUS DEVICE RESET rejected");
6167 case RQCS_ID_MSG_FAILED:
6168 isp_xs_prt(isp, xs, ISP_LOGERR, "IDENTIFY rejected");
6171 case RQCS_UNEXP_BUS_FREE:
6172 isp_xs_prt(isp, xs, ISP_LOGERR, "Unexpected Bus Free");
6175 case RQCS_DATA_UNDERRUN:
6178 int ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
6179 if (!ru_marked || sp->req_resid > XS_XFRLEN(xs)) {
6180 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6182 XS_SETERR(xs, HBA_BOTCH);
6187 XS_SET_RESID(xs, sp->req_resid);
6189 XS_SETERR(xs, HBA_NOERROR);
6194 case RQCS_XACT_ERR1:
6195 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued transaction with disconnect not set");
6198 case RQCS_XACT_ERR2:
6199 isp_xs_prt(isp, xs, ISP_LOGERR,
6200 "HBA attempted queued transaction to target routine %jx",
6201 (uintmax_t)XS_LUN(xs));
6204 case RQCS_XACT_ERR3:
6205 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued cmd when queueing disabled");
6208 case RQCS_BAD_ENTRY:
6209 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
6212 case RQCS_QUEUE_FULL:
6213 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "internal queues full status 0x%x", *XS_STSP(xs));
6216 * If QFULL or some other status byte is set, then this
6217 * isn't an error, per se.
6219 * Unfortunately, some QLogic f/w writers have, in
6220 * some cases, omitted to *set* status to QFULL.
6223 if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
6224 XS_SETERR(xs, HBA_NOERROR);
6229 *XS_STSP(xs) = SCSI_QFULL;
6230 XS_SETERR(xs, HBA_NOERROR);
6233 case RQCS_PHASE_SKIPPED:
6234 isp_xs_prt(isp, xs, ISP_LOGERR, "SCSI phase skipped");
6237 case RQCS_ARQS_FAILED:
6238 isp_xs_prt(isp, xs, ISP_LOGERR, "Auto Request Sense Failed");
6240 XS_SETERR(xs, HBA_ARQFAIL);
6244 case RQCS_WIDE_FAILED:
6245 isp_xs_prt(isp, xs, ISP_LOGERR, "Wide Negotiation Failed");
6247 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
6248 sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_WIDE;
6249 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
6253 XS_SETERR(xs, HBA_NOERROR);
6257 case RQCS_SYNCXFER_FAILED:
6258 isp_xs_prt(isp, xs, ISP_LOGERR, "SDTR Message Failed");
6260 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
6261 sdp += XS_CHANNEL(xs);
6262 sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_SYNC;
6263 sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
6268 case RQCS_LVD_BUSERR:
6269 isp_xs_prt(isp, xs, ISP_LOGERR, "Bad LVD condition");
6272 case RQCS_PORT_UNAVAILABLE:
6274 * No such port on the loop. Moral equivalent of SELTIMEO
6276 case RQCS_PORT_LOGGED_OUT:
6279 uint8_t sts = sp->req_completion_status & 0xff;
6280 fcparam *fcp = FCPARAM(isp, 0);
6284 * It was there (maybe)- treat as a selection timeout.
6286 if (sts == RQCS_PORT_UNAVAILABLE) {
6287 reason = "unavailable";
6292 isp_prt(isp, ISP_LOGINFO, "port %s for target %d", reason, XS_TGT(xs));
6294 /* XXX: Should we trigger rescan or FW announce change? */
6297 lp = &fcp->portdb[XS_TGT(xs)];
6298 if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
6299 *XS_STSP(xs) = SCSI_BUSY;
6300 XS_SETERR(xs, HBA_TGTBSY);
6302 XS_SETERR(xs, HBA_SELTIMEOUT);
6306 case RQCS_PORT_CHANGED:
6307 isp_prt(isp, ISP_LOGWARN, "port changed for target %d", XS_TGT(xs));
6309 *XS_STSP(xs) = SCSI_BUSY;
6310 XS_SETERR(xs, HBA_TGTBSY);
6314 case RQCS_PORT_BUSY:
6315 isp_prt(isp, ISP_LOGWARN, "port busy for target %d", XS_TGT(xs));
6317 *XS_STSP(xs) = SCSI_BUSY;
6318 XS_SETERR(xs, HBA_TGTBSY);
6323 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x", sp->req_completion_status);
6327 XS_SETERR(xs, HBA_BOTCH);
6332 isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp, XS_T *xs, uint32_t *rp)
6334 int ru_marked, sv_marked;
6335 int chan = XS_CHANNEL(xs);
6337 switch (sp->req_completion_status) {
6340 XS_SETERR(xs, HBA_NOERROR);
6344 case RQCS_DMA_ERROR:
6345 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA error");
6348 case RQCS_TRANSPORT_ERROR:
6349 isp_xs_prt(isp, xs, ISP_LOGERR, "Transport Error");
6352 case RQCS_RESET_OCCURRED:
6353 isp_xs_prt(isp, xs, ISP_LOGWARN, "reset destroyed command");
6354 FCPARAM(isp, chan)->sendmarker = 1;
6356 XS_SETERR(xs, HBA_BUSRESET);
6361 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
6362 FCPARAM(isp, chan)->sendmarker = 1;
6364 XS_SETERR(xs, HBA_ABORTED);
6369 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command Timed Out");
6371 XS_SETERR(xs, HBA_CMDTIMEOUT);
6375 case RQCS_DATA_OVERRUN:
6376 XS_SET_RESID(xs, sp->req_resid);
6377 isp_xs_prt(isp, xs, ISP_LOGERR, "Data Overrun");
6379 XS_SETERR(xs, HBA_DATAOVR);
6383 case RQCS_24XX_DRE: /* data reassembly error */
6384 isp_prt(isp, ISP_LOGERR, "Chan %d data reassembly error for target %d", chan, XS_TGT(xs));
6386 XS_SETERR(xs, HBA_ABORTED);
6388 *rp = XS_XFRLEN(xs);
6391 case RQCS_24XX_TABORT: /* aborted by target */
6392 isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS", chan, XS_TGT(xs));
6394 XS_SETERR(xs, HBA_ABORTED);
6398 case RQCS_DATA_UNDERRUN:
6399 ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
6401 * We can get an underrun w/o things being marked
6402 * if we got a non-zero status.
6404 sv_marked = (sp->req_scsi_status & (RQCS_SV|RQCS_RV)) != 0;
6405 if ((ru_marked == 0 && sv_marked == 0) ||
6406 (sp->req_resid > XS_XFRLEN(xs))) {
6407 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6409 XS_SETERR(xs, HBA_BOTCH);
6413 XS_SET_RESID(xs, sp->req_resid);
6414 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
6416 XS_SETERR(xs, HBA_NOERROR);
6420 case RQCS_PORT_UNAVAILABLE:
6422 * No such port on the loop. Moral equivalent of SELTIMEO
6424 case RQCS_PORT_LOGGED_OUT:
6427 uint8_t sts = sp->req_completion_status & 0xff;
6428 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
6432 * It was there (maybe)- treat as a selection timeout.
6434 if (sts == RQCS_PORT_UNAVAILABLE) {
6435 reason = "unavailable";
6440 isp_prt(isp, ISP_LOGINFO, "Chan %d port %s for target %d",
6441 chan, reason, XS_TGT(xs));
6443 /* XXX: Should we trigger rescan or FW announce change? */
6446 lp = &fcp->portdb[XS_TGT(xs)];
6447 if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
6448 *XS_STSP(xs) = SCSI_BUSY;
6449 XS_SETERR(xs, HBA_TGTBSY);
6451 XS_SETERR(xs, HBA_SELTIMEOUT);
6455 case RQCS_PORT_CHANGED:
6456 isp_prt(isp, ISP_LOGWARN, "port changed for target %d chan %d", XS_TGT(xs), chan);
6458 *XS_STSP(xs) = SCSI_BUSY;
6459 XS_SETERR(xs, HBA_TGTBSY);
6463 case RQCS_24XX_ENOMEM: /* f/w resource unavailable */
6464 isp_prt(isp, ISP_LOGWARN, "f/w resource unavailable for target %d chan %d", XS_TGT(xs), chan);
6466 *XS_STSP(xs) = SCSI_BUSY;
6467 XS_SETERR(xs, HBA_TGTBSY);
6471 case RQCS_24XX_TMO: /* task management overrun */
6472 isp_prt(isp, ISP_LOGWARN, "command for target %d overlapped task management for chan %d", XS_TGT(xs), chan);
6474 *XS_STSP(xs) = SCSI_BUSY;
6475 XS_SETERR(xs, HBA_TGTBSY);
6480 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x on chan %d", sp->req_completion_status, chan);
6484 XS_SETERR(xs, HBA_BOTCH);
6489 isp_fastpost_complete(ispsoftc_t *isp, uint32_t fph)
6496 xs = isp_find_xs(isp, fph);
6498 isp_prt(isp, ISP_LOGWARN,
6499 "Command for fast post handle 0x%x not found", fph);
6502 isp_destroy_handle(isp, fph);
6505 * Since we don't have a result queue entry item,
6506 * we must believe that SCSI status is zero and
6507 * that all data transferred.
6509 XS_SET_RESID(xs, 0);
6510 *XS_STSP(xs) = SCSI_GOOD;
6511 if (XS_XFRLEN(xs)) {
6512 ISP_DMAFREE(isp, xs, fph);
6517 #define ISP_SCSI_IBITS(op) (mbpscsi[((op)<<1)])
6518 #define ISP_SCSI_OBITS(op) (mbpscsi[((op)<<1) + 1])
6519 #define ISP_SCSI_OPMAP(in, out) in, out
6520 static const uint8_t mbpscsi[] = {
6521 ISP_SCSI_OPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
6522 ISP_SCSI_OPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
6523 ISP_SCSI_OPMAP(0x03, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */
6524 ISP_SCSI_OPMAP(0x1f, 0x01), /* 0x03: MBOX_DUMP_RAM */
6525 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
6526 ISP_SCSI_OPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
6527 ISP_SCSI_OPMAP(0x3f, 0x3f), /* 0x06: MBOX_MAILBOX_REG_TEST */
6528 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */
6529 ISP_SCSI_OPMAP(0x01, 0x0f), /* 0x08: MBOX_ABOUT_FIRMWARE */
6530 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x09: */
6531 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x0a: */
6532 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x0b: */
6533 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x0c: */
6534 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x0d: */
6535 ISP_SCSI_OPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
6536 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x0f: */
6537 ISP_SCSI_OPMAP(0x1f, 0x1f), /* 0x10: MBOX_INIT_REQ_QUEUE */
6538 ISP_SCSI_OPMAP(0x3f, 0x3f), /* 0x11: MBOX_INIT_RES_QUEUE */
6539 ISP_SCSI_OPMAP(0x0f, 0x0f), /* 0x12: MBOX_EXECUTE_IOCB */
6540 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */
6541 ISP_SCSI_OPMAP(0x01, 0x3f), /* 0x14: MBOX_STOP_FIRMWARE */
6542 ISP_SCSI_OPMAP(0x0f, 0x0f), /* 0x15: MBOX_ABORT */
6543 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x16: MBOX_ABORT_DEVICE */
6544 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x17: MBOX_ABORT_TARGET */
6545 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x18: MBOX_BUS_RESET */
6546 ISP_SCSI_OPMAP(0x03, 0x07), /* 0x19: MBOX_STOP_QUEUE */
6547 ISP_SCSI_OPMAP(0x03, 0x07), /* 0x1a: MBOX_START_QUEUE */
6548 ISP_SCSI_OPMAP(0x03, 0x07), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6549 ISP_SCSI_OPMAP(0x03, 0x07), /* 0x1c: MBOX_ABORT_QUEUE */
6550 ISP_SCSI_OPMAP(0x03, 0x4f), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6551 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x1e: */
6552 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6553 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x20: MBOX_GET_INIT_SCSI_ID */
6554 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x21: MBOX_GET_SELECT_TIMEOUT */
6555 ISP_SCSI_OPMAP(0x01, 0xc7), /* 0x22: MBOX_GET_RETRY_COUNT */
6556 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
6557 ISP_SCSI_OPMAP(0x01, 0x03), /* 0x24: MBOX_GET_CLOCK_RATE */
6558 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x25: MBOX_GET_ACT_NEG_STATE */
6559 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
6560 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x27: MBOX_GET_PCI_PARAMS */
6561 ISP_SCSI_OPMAP(0x03, 0x4f), /* 0x28: MBOX_GET_TARGET_PARAMS */
6562 ISP_SCSI_OPMAP(0x03, 0x0f), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
6563 ISP_SCSI_OPMAP(0x01, 0x07), /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */
6564 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x2b: */
6565 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x2c: */
6566 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x2d: */
6567 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x2e: */
6568 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x2f: */
6569 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x30: MBOX_SET_INIT_SCSI_ID */
6570 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x31: MBOX_SET_SELECT_TIMEOUT */
6571 ISP_SCSI_OPMAP(0xc7, 0xc7), /* 0x32: MBOX_SET_RETRY_COUNT */
6572 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
6573 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x34: MBOX_SET_CLOCK_RATE */
6574 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x35: MBOX_SET_ACT_NEG_STATE */
6575 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
6576 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
6577 ISP_SCSI_OPMAP(0x4f, 0x4f), /* 0x38: MBOX_SET_TARGET_PARAMS */
6578 ISP_SCSI_OPMAP(0x0f, 0x0f), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
6579 ISP_SCSI_OPMAP(0x07, 0x07), /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */
6580 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x3b: */
6581 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x3c: */
6582 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x3d: */
6583 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x3e: */
6584 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x3f: */
6585 ISP_SCSI_OPMAP(0x01, 0x03), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
6586 ISP_SCSI_OPMAP(0x3f, 0x01), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
6587 ISP_SCSI_OPMAP(0x03, 0x07), /* 0x42: MBOX_EXEC_BIOS_IOCB */
6588 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x43: */
6589 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x44: */
6590 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x45: SET SYSTEM PARAMETER */
6591 ISP_SCSI_OPMAP(0x01, 0x03), /* 0x46: GET SYSTEM PARAMETER */
6592 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x47: */
6593 ISP_SCSI_OPMAP(0x01, 0xcf), /* 0x48: GET SCAM CONFIGURATION */
6594 ISP_SCSI_OPMAP(0xcf, 0xcf), /* 0x49: SET SCAM CONFIGURATION */
6595 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x4a: MBOX_SET_FIRMWARE_FEATURES */
6596 ISP_SCSI_OPMAP(0x01, 0x03), /* 0x4b: MBOX_GET_FIRMWARE_FEATURES */
6597 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x4c: */
6598 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x4d: */
6599 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x4e: */
6600 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x4f: */
6601 ISP_SCSI_OPMAP(0xdf, 0xdf), /* 0x50: LOAD RAM A64 */
6602 ISP_SCSI_OPMAP(0xdf, 0xdf), /* 0x51: DUMP RAM A64 */
6603 ISP_SCSI_OPMAP(0xdf, 0xff), /* 0x52: INITIALIZE REQUEST QUEUE A64 */
6604 ISP_SCSI_OPMAP(0xef, 0xff), /* 0x53: INITIALIZE RESPONSE QUEUE A64 */
6605 ISP_SCSI_OPMAP(0xcf, 0x01), /* 0x54: EXECUCUTE COMMAND IOCB A64 */
6606 ISP_SCSI_OPMAP(0x07, 0x01), /* 0x55: ENABLE TARGET MODE */
6607 ISP_SCSI_OPMAP(0x03, 0x0f), /* 0x56: GET TARGET STATUS */
6608 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x57: */
6609 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x58: */
6610 ISP_SCSI_OPMAP(0x00, 0x00), /* 0x59: */
6611 ISP_SCSI_OPMAP(0x03, 0x03), /* 0x5a: SET DATA OVERRUN RECOVERY MODE */
6612 ISP_SCSI_OPMAP(0x01, 0x03), /* 0x5b: GET DATA OVERRUN RECOVERY MODE */
6613 ISP_SCSI_OPMAP(0x0f, 0x0f), /* 0x5c: SET HOST DATA */
6614 ISP_SCSI_OPMAP(0x01, 0x01) /* 0x5d: GET NOST DATA */
6616 #define MAX_SCSI_OPCODE 0x5d
6618 static const char *scsi_mbcmd_names[] = {
6635 "INIT REQUEST QUEUE",
6636 "INIT RESULT QUEUE",
6646 "SINGLE STEP QUEUE",
6648 "GET DEV QUEUE STATUS",
6650 "GET FIRMWARE STATUS",
6652 "GET SELECT TIMEOUT",
6654 "GET TAG AGE LIMIT",
6656 "GET ACT NEG STATE",
6657 "GET ASYNC DATA SETUP TIME",
6659 "GET TARGET PARAMS",
6660 "GET DEV QUEUE PARAMS",
6661 "GET RESET DELAY PARAMS",
6668 "SET SELECT TIMEOUT",
6670 "SET TAG AGE LIMIT",
6672 "SET ACT NEG STATE",
6673 "SET ASYNC DATA SETUP TIME",
6674 "SET PCI CONTROL PARAMS",
6675 "SET TARGET PARAMS",
6676 "SET DEV QUEUE PARAMS",
6677 "SET RESET DELAY PARAMS",
6683 "RETURN BIOS BLOCK ADDR",
6684 "WRITE FOUR RAM WORDS",
6688 "SET SYSTEM PARAMETER",
6689 "GET SYSTEM PARAMETER",
6691 "GET SCAM CONFIGURATION",
6692 "SET SCAM CONFIGURATION",
6693 "SET FIRMWARE FEATURES",
6694 "GET FIRMWARE FEATURES",
6701 "INITIALIZE REQUEST QUEUE A64",
6702 "INITIALIZE RESPONSE QUEUE A64",
6704 "ENABLE TARGET MODE",
6705 "GET TARGET MODE STATE",
6709 "SET DATA OVERRUN RECOVERY MODE",
6710 "GET DATA OVERRUN RECOVERY MODE",
6715 #define ISP_FC_IBITS(op) ((mbpfc[((op)<<3) + 0] << 24) | (mbpfc[((op)<<3) + 1] << 16) | (mbpfc[((op)<<3) + 2] << 8) | (mbpfc[((op)<<3) + 3]))
6716 #define ISP_FC_OBITS(op) ((mbpfc[((op)<<3) + 4] << 24) | (mbpfc[((op)<<3) + 5] << 16) | (mbpfc[((op)<<3) + 6] << 8) | (mbpfc[((op)<<3) + 7]))
6718 #define ISP_FC_OPMAP(in0, out0) 0, 0, 0, in0, 0, 0, 0, out0
6719 #define ISP_FC_OPMAP_HALF(in1, in0, out1, out0) 0, 0, in1, in0, 0, 0, out1, out0
6720 #define ISP_FC_OPMAP_FULL(in3, in2, in1, in0, out3, out2, out1, out0) in3, in2, in1, in0, out3, out2, out1, out0
6721 static const uint32_t mbpfc[] = {
6722 ISP_FC_OPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
6723 ISP_FC_OPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
6724 ISP_FC_OPMAP_HALF(0x07, 0xff, 0x00, 0x03), /* 0x02: MBOX_EXEC_FIRMWARE */
6725 ISP_FC_OPMAP(0xdf, 0x01), /* 0x03: MBOX_DUMP_RAM */
6726 ISP_FC_OPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
6727 ISP_FC_OPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
6728 ISP_FC_OPMAP_FULL(0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff), /* 0x06: MBOX_MAILBOX_REG_TEST */
6729 ISP_FC_OPMAP(0x07, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */
6730 ISP_FC_OPMAP_FULL(0x0, 0x0, 0x0, 0x01, 0x0, 0x3, 0x80, 0x7f), /* 0x08: MBOX_ABOUT_FIRMWARE */
6731 ISP_FC_OPMAP(0xdf, 0x01), /* 0x09: MBOX_LOAD_RISC_RAM_2100 */
6732 ISP_FC_OPMAP(0xdf, 0x01), /* 0x0a: DUMP RAM */
6733 ISP_FC_OPMAP_HALF(0x1, 0xff, 0x0, 0x01), /* 0x0b: MBOX_LOAD_RISC_RAM */
6734 ISP_FC_OPMAP(0x00, 0x00), /* 0x0c: */
6735 ISP_FC_OPMAP_HALF(0x1, 0x0f, 0x0, 0x01), /* 0x0d: MBOX_WRITE_RAM_WORD_EXTENDED */
6736 ISP_FC_OPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
6737 ISP_FC_OPMAP_HALF(0x1, 0x03, 0x0, 0x0d), /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED */
6738 ISP_FC_OPMAP(0x1f, 0x11), /* 0x10: MBOX_INIT_REQ_QUEUE */
6739 ISP_FC_OPMAP(0x2f, 0x21), /* 0x11: MBOX_INIT_RES_QUEUE */
6740 ISP_FC_OPMAP(0x0f, 0x01), /* 0x12: MBOX_EXECUTE_IOCB */
6741 ISP_FC_OPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */
6742 ISP_FC_OPMAP_HALF(0x1, 0xff, 0x0, 0x03), /* 0x14: MBOX_STOP_FIRMWARE */
6743 ISP_FC_OPMAP(0x4f, 0x01), /* 0x15: MBOX_ABORT */
6744 ISP_FC_OPMAP(0x07, 0x01), /* 0x16: MBOX_ABORT_DEVICE */
6745 ISP_FC_OPMAP(0x07, 0x01), /* 0x17: MBOX_ABORT_TARGET */
6746 ISP_FC_OPMAP(0x03, 0x03), /* 0x18: MBOX_BUS_RESET */
6747 ISP_FC_OPMAP(0x07, 0x05), /* 0x19: MBOX_STOP_QUEUE */
6748 ISP_FC_OPMAP(0x07, 0x05), /* 0x1a: MBOX_START_QUEUE */
6749 ISP_FC_OPMAP(0x07, 0x05), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6750 ISP_FC_OPMAP(0x07, 0x05), /* 0x1c: MBOX_ABORT_QUEUE */
6751 ISP_FC_OPMAP(0x07, 0x03), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6752 ISP_FC_OPMAP(0x00, 0x00), /* 0x1e: */
6753 ISP_FC_OPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6754 ISP_FC_OPMAP_HALF(0x2, 0x01, 0x7e, 0xcf), /* 0x20: MBOX_GET_LOOP_ID */
6755 ISP_FC_OPMAP(0x00, 0x00), /* 0x21: */
6756 ISP_FC_OPMAP(0x03, 0x4b), /* 0x22: MBOX_GET_TIMEOUT_PARAMS */
6757 ISP_FC_OPMAP(0x00, 0x00), /* 0x23: */
6758 ISP_FC_OPMAP(0x00, 0x00), /* 0x24: */
6759 ISP_FC_OPMAP(0x00, 0x00), /* 0x25: */
6760 ISP_FC_OPMAP(0x00, 0x00), /* 0x26: */
6761 ISP_FC_OPMAP(0x00, 0x00), /* 0x27: */
6762 ISP_FC_OPMAP(0x01, 0x03), /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */
6763 ISP_FC_OPMAP(0x03, 0x07), /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */
6764 ISP_FC_OPMAP(0x00, 0x00), /* 0x2a: */
6765 ISP_FC_OPMAP(0x00, 0x00), /* 0x2b: */
6766 ISP_FC_OPMAP(0x00, 0x00), /* 0x2c: */
6767 ISP_FC_OPMAP(0x00, 0x00), /* 0x2d: */
6768 ISP_FC_OPMAP(0x00, 0x00), /* 0x2e: */
6769 ISP_FC_OPMAP(0x00, 0x00), /* 0x2f: */
6770 ISP_FC_OPMAP(0x00, 0x00), /* 0x30: */
6771 ISP_FC_OPMAP(0x00, 0x00), /* 0x31: */
6772 ISP_FC_OPMAP(0x4b, 0x4b), /* 0x32: MBOX_SET_TIMEOUT_PARAMS */
6773 ISP_FC_OPMAP(0x00, 0x00), /* 0x33: */
6774 ISP_FC_OPMAP(0x00, 0x00), /* 0x34: */
6775 ISP_FC_OPMAP(0x00, 0x00), /* 0x35: */
6776 ISP_FC_OPMAP(0x00, 0x00), /* 0x36: */
6777 ISP_FC_OPMAP(0x00, 0x00), /* 0x37: */
6778 ISP_FC_OPMAP(0x0f, 0x01), /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */
6779 ISP_FC_OPMAP(0x0f, 0x07), /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */
6780 ISP_FC_OPMAP(0x00, 0x00), /* 0x3a: */
6781 ISP_FC_OPMAP(0x00, 0x00), /* 0x3b: */
6782 ISP_FC_OPMAP(0x00, 0x00), /* 0x3c: */
6783 ISP_FC_OPMAP(0x00, 0x00), /* 0x3d: */
6784 ISP_FC_OPMAP(0x00, 0x00), /* 0x3e: */
6785 ISP_FC_OPMAP(0x00, 0x00), /* 0x3f: */
6786 ISP_FC_OPMAP(0x03, 0x01), /* 0x40: MBOX_LOOP_PORT_BYPASS */
6787 ISP_FC_OPMAP(0x03, 0x01), /* 0x41: MBOX_LOOP_PORT_ENABLE */
6788 ISP_FC_OPMAP_HALF(0x0, 0x01, 0x1f, 0xcf), /* 0x42: MBOX_GET_RESOURCE_COUNT */
6789 ISP_FC_OPMAP(0x01, 0x01), /* 0x43: MBOX_REQUEST_OFFLINE_MODE */
6790 ISP_FC_OPMAP(0x00, 0x00), /* 0x44: */
6791 ISP_FC_OPMAP(0x00, 0x00), /* 0x45: */
6792 ISP_FC_OPMAP(0x00, 0x00), /* 0x46: */
6793 ISP_FC_OPMAP(0xcf, 0x03), /* 0x47: GET PORT_DATABASE ENHANCED */
6794 ISP_FC_OPMAP(0xcf, 0x0f), /* 0x48: MBOX_INIT_FIRMWARE_MULTI_ID */
6795 ISP_FC_OPMAP(0xcd, 0x01), /* 0x49: MBOX_GET_VP_DATABASE */
6796 ISP_FC_OPMAP_HALF(0x2, 0xcd, 0x0, 0x01), /* 0x4a: MBOX_GET_VP_DATABASE_ENTRY */
6797 ISP_FC_OPMAP(0x00, 0x00), /* 0x4b: */
6798 ISP_FC_OPMAP(0x00, 0x00), /* 0x4c: */
6799 ISP_FC_OPMAP(0x00, 0x00), /* 0x4d: */
6800 ISP_FC_OPMAP(0x00, 0x00), /* 0x4e: */
6801 ISP_FC_OPMAP(0x00, 0x00), /* 0x4f: */
6802 ISP_FC_OPMAP(0x00, 0x00), /* 0x50: */
6803 ISP_FC_OPMAP(0x00, 0x00), /* 0x51: */
6804 ISP_FC_OPMAP(0x00, 0x00), /* 0x52: */
6805 ISP_FC_OPMAP(0x00, 0x00), /* 0x53: */
6806 ISP_FC_OPMAP(0xcf, 0x01), /* 0x54: EXECUTE IOCB A64 */
6807 ISP_FC_OPMAP(0x00, 0x00), /* 0x55: */
6808 ISP_FC_OPMAP(0x00, 0x00), /* 0x56: */
6809 ISP_FC_OPMAP(0x00, 0x00), /* 0x57: */
6810 ISP_FC_OPMAP(0x00, 0x00), /* 0x58: */
6811 ISP_FC_OPMAP(0x00, 0x00), /* 0x59: */
6812 ISP_FC_OPMAP(0x00, 0x00), /* 0x5a: */
6813 ISP_FC_OPMAP(0x03, 0x01), /* 0x5b: MBOX_DRIVER_HEARTBEAT */
6814 ISP_FC_OPMAP(0xcf, 0x01), /* 0x5c: MBOX_FW_HEARTBEAT */
6815 ISP_FC_OPMAP(0x07, 0x1f), /* 0x5d: MBOX_GET_SET_DATA_RATE */
6816 ISP_FC_OPMAP(0x00, 0x00), /* 0x5e: */
6817 ISP_FC_OPMAP(0x00, 0x00), /* 0x5f: */
6818 ISP_FC_OPMAP(0xcf, 0x0f), /* 0x60: MBOX_INIT_FIRMWARE */
6819 ISP_FC_OPMAP(0x00, 0x00), /* 0x61: */
6820 ISP_FC_OPMAP(0x01, 0x01), /* 0x62: MBOX_INIT_LIP */
6821 ISP_FC_OPMAP(0xcd, 0x03), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
6822 ISP_FC_OPMAP(0xcf, 0x01), /* 0x64: MBOX_GET_PORT_DB */
6823 ISP_FC_OPMAP(0x07, 0x01), /* 0x65: MBOX_CLEAR_ACA */
6824 ISP_FC_OPMAP(0x07, 0x01), /* 0x66: MBOX_TARGET_RESET */
6825 ISP_FC_OPMAP(0x07, 0x01), /* 0x67: MBOX_CLEAR_TASK_SET */
6826 ISP_FC_OPMAP(0x07, 0x01), /* 0x68: MBOX_ABORT_TASK_SET */
6827 ISP_FC_OPMAP(0x01, 0x07), /* 0x69: MBOX_GET_FW_STATE */
6828 ISP_FC_OPMAP_HALF(0x6, 0x03, 0x0, 0xcf), /* 0x6a: MBOX_GET_PORT_NAME */
6829 ISP_FC_OPMAP(0xcf, 0x01), /* 0x6b: MBOX_GET_LINK_STATUS */
6830 ISP_FC_OPMAP(0x0f, 0x01), /* 0x6c: MBOX_INIT_LIP_RESET */
6831 ISP_FC_OPMAP(0x00, 0x00), /* 0x6d: */
6832 ISP_FC_OPMAP(0xcf, 0x03), /* 0x6e: MBOX_SEND_SNS */
6833 ISP_FC_OPMAP(0x0f, 0x07), /* 0x6f: MBOX_FABRIC_LOGIN */
6834 ISP_FC_OPMAP_HALF(0x02, 0x03, 0x00, 0x03), /* 0x70: MBOX_SEND_CHANGE_REQUEST */
6835 ISP_FC_OPMAP(0x03, 0x03), /* 0x71: MBOX_FABRIC_LOGOUT */
6836 ISP_FC_OPMAP(0x0f, 0x0f), /* 0x72: MBOX_INIT_LIP_LOGIN */
6837 ISP_FC_OPMAP(0x00, 0x00), /* 0x73: */
6838 ISP_FC_OPMAP(0x07, 0x01), /* 0x74: LOGIN LOOP PORT */
6839 ISP_FC_OPMAP_HALF(0x03, 0xcf, 0x00, 0x07), /* 0x75: GET PORT/NODE NAME LIST */
6840 ISP_FC_OPMAP(0x4f, 0x01), /* 0x76: SET VENDOR ID */
6841 ISP_FC_OPMAP(0xcd, 0x01), /* 0x77: INITIALIZE IP MAILBOX */
6842 ISP_FC_OPMAP(0x00, 0x00), /* 0x78: */
6843 ISP_FC_OPMAP(0x00, 0x00), /* 0x79: */
6844 ISP_FC_OPMAP(0x00, 0x00), /* 0x7a: */
6845 ISP_FC_OPMAP(0x00, 0x00), /* 0x7b: */
6846 ISP_FC_OPMAP_HALF(0x03, 0x4f, 0x00, 0x07), /* 0x7c: Get ID List */
6847 ISP_FC_OPMAP(0xcf, 0x01), /* 0x7d: SEND LFA */
6848 ISP_FC_OPMAP(0x0f, 0x01) /* 0x7e: LUN RESET */
6850 #define MAX_FC_OPCODE 0x7e
6854 * (1): this sets bits 21..16 in mailbox register #8, which we nominally
6855 * do not access at this time in the core driver. The caller is
6856 * responsible for setting this register first (Gross!). The assumption
6857 * is that we won't overflow.
6860 static const char *fc_mbcmd_names[] = {
6874 "WRITE RAM WORD EXTENDED",
6876 "READ RAM WORD EXTENDED",
6877 "INIT REQUEST QUEUE", /* 10h */
6878 "INIT RESULT QUEUE",
6888 "SINGLE STEP QUEUE",
6890 "GET DEV QUEUE STATUS",
6892 "GET FIRMWARE STATUS",
6893 "GET LOOP ID", /* 20h */
6895 "GET TIMEOUT PARAMS",
6901 "GET FIRMWARE OPTIONS",
6902 "GET PORT QUEUE PARAMS",
6903 "GENERATE SYSTEM ERROR",
6909 "WRITE SFP", /* 30h */
6911 "SET TIMEOUT PARAMS",
6917 "SET FIRMWARE OPTIONS",
6918 "SET PORT QUEUE PARAMS",
6922 "RESTART NIC FIRMWARE",
6925 "LOOP PORT BYPASS", /* 40h */
6927 "GET RESOURCE COUNT",
6928 "REQUEST NON PARTICIPATING MODE",
6929 "DIAGNOSTIC ECHO TEST",
6930 "DIAGNOSTIC LOOPBACK",
6932 "GET PORT DATABASE ENHANCED",
6933 "INIT FIRMWARE MULTI ID",
6935 "GET VP DATABASE ENTRY",
6941 "GET FCF LIST", /* 50h */
6942 "GET DCBX PARAMETERS",
6953 "FIRMWARE HEARTBEAT",
6954 "GET/SET DATA RATE",
6957 "INIT FIRMWARE", /* 60h */
6958 "GET INIT CONTROL BLOCK",
6960 "GET FC-AL POSITION MAP",
6961 "GET PORT DATABASE",
6970 "GET LINK STATS & PRIVATE DATA CNTS",
6973 "SEND CHANGE REQUEST", /* 70h */
6978 "GET PORT/NODE NAME LIST",
6980 "INITIALIZE IP MAILBOX",
6991 isp_mboxcmd(ispsoftc_t *isp, mbreg_t *mbp)
6993 const char *cname, *xname, *sname;
6994 char tname[16], mname[16];
6995 unsigned int ibits, obits, box, opcode;
6997 opcode = mbp->param[0];
6999 if (opcode > MAX_FC_OPCODE) {
7000 mbp->param[0] = MBOX_INVALID_COMMAND;
7001 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
7004 cname = fc_mbcmd_names[opcode];
7005 ibits = ISP_FC_IBITS(opcode);
7006 obits = ISP_FC_OBITS(opcode);
7008 if (opcode > MAX_SCSI_OPCODE) {
7009 mbp->param[0] = MBOX_INVALID_COMMAND;
7010 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
7013 cname = scsi_mbcmd_names[opcode];
7014 ibits = ISP_SCSI_IBITS(opcode);
7015 obits = ISP_SCSI_OBITS(opcode);
7017 if (cname == NULL) {
7019 ISP_SNPRINTF(tname, sizeof tname, "opcode %x", opcode);
7021 isp_prt(isp, ISP_LOGDEBUG3, "Mailbox Command '%s'", cname);
7024 * Pick up any additional bits that the caller might have set.
7026 ibits |= mbp->ibits;
7027 obits |= mbp->obits;
7030 * Mask any bits that the caller wants us to mask
7032 ibits &= mbp->ibitm;
7033 obits &= mbp->obitm;
7036 if (ibits == 0 && obits == 0) {
7037 mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
7038 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
7043 * Get exclusive usage of mailbox registers.
7045 if (MBOX_ACQUIRE(isp)) {
7046 mbp->param[0] = MBOX_REGS_BUSY;
7050 for (box = 0; box < ISP_NMBOX(isp); box++) {
7051 if (ibits & (1 << box)) {
7052 isp_prt(isp, ISP_LOGDEBUG3, "IN mbox %d = 0x%04x", box,
7054 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
7056 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
7059 isp->isp_lastmbxcmd = opcode;
7062 * We assume that we can't overwrite a previous command.
7064 isp->isp_obits = obits;
7065 isp->isp_mboxbsy = 1;
7068 * Set Host Interrupt condition so that RISC will pick up mailbox regs.
7071 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
7073 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
7077 * While we haven't finished the command, spin our wheels here.
7079 MBOX_WAIT_COMPLETE(isp, mbp);
7082 * Did the command time out?
7084 if (mbp->param[0] == MBOX_TIMEOUT) {
7085 isp->isp_mboxbsy = 0;
7091 * Copy back output registers.
7093 for (box = 0; box < ISP_NMBOX(isp); box++) {
7094 if (obits & (1 << box)) {
7095 mbp->param[box] = isp->isp_mboxtmp[box];
7096 isp_prt(isp, ISP_LOGDEBUG3, "OUT mbox %d = 0x%04x", box,
7101 isp->isp_mboxbsy = 0;
7104 if (mbp->logval == 0 || mbp->param[0] == MBOX_COMMAND_COMPLETE)
7107 if ((mbp->param[0] & 0xbfe0) == 0 &&
7108 (mbp->logval & MBLOGMASK(mbp->param[0])) == 0)
7113 switch (mbp->param[0]) {
7114 case MBOX_INVALID_COMMAND:
7115 xname = "INVALID COMMAND";
7117 case MBOX_HOST_INTERFACE_ERROR:
7118 xname = "HOST INTERFACE ERROR";
7120 case MBOX_TEST_FAILED:
7121 xname = "TEST FAILED";
7123 case MBOX_COMMAND_ERROR:
7124 xname = "COMMAND ERROR";
7125 ISP_SNPRINTF(mname, sizeof(mname), " subcode 0x%x",
7129 case MBOX_COMMAND_PARAM_ERROR:
7130 xname = "COMMAND PARAMETER ERROR";
7132 case MBOX_PORT_ID_USED:
7133 xname = "PORT ID ALREADY IN USE";
7135 case MBOX_LOOP_ID_USED:
7136 xname = "LOOP ID ALREADY IN USE";
7138 case MBOX_ALL_IDS_USED:
7139 xname = "ALL LOOP IDS IN USE";
7141 case MBOX_NOT_LOGGED_IN:
7142 xname = "NOT LOGGED IN";
7144 case MBOX_LINK_DOWN_ERROR:
7145 xname = "LINK DOWN ERROR";
7147 case MBOX_LOOPBACK_ERROR:
7148 xname = "LOOPBACK ERROR";
7150 case MBOX_CHECKSUM_ERROR:
7151 xname = "CHECKSUM ERROR";
7153 case MBOX_INVALID_PRODUCT_KEY:
7154 xname = "INVALID PRODUCT KEY";
7156 case MBOX_REGS_BUSY:
7157 xname = "REGISTERS BUSY";
7163 ISP_SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
7168 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s%s)",
7169 cname, xname, sname);
7174 isp_fw_state(ispsoftc_t *isp, int chan)
7179 MBSINIT(&mbs, MBOX_GET_FW_STATE, MBLOGALL, 0);
7180 isp_mboxcmd(isp, &mbs);
7181 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
7182 return (mbs.param[1]);
7189 isp_spi_update(ispsoftc_t *isp, int chan)
7197 * There are no 'per-bus' settings for Fibre Channel.
7201 sdp = SDPARAM(isp, chan);
7204 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7205 uint16_t flags, period, offset;
7208 if (sdp->isp_devparam[tgt].dev_enable == 0) {
7209 sdp->isp_devparam[tgt].dev_update = 0;
7210 sdp->isp_devparam[tgt].dev_refresh = 0;
7211 isp_prt(isp, ISP_LOGDEBUG0, "skipping target %d bus %d update", tgt, chan);
7215 * If the goal is to update the status of the device,
7216 * take what's in goal_flags and try and set the device
7217 * toward that. Otherwise, if we're just refreshing the
7218 * current device state, get the current parameters.
7221 MBSINIT(&mbs, 0, MBLOGALL, 0);
7224 * Refresh overrides set
7226 if (sdp->isp_devparam[tgt].dev_refresh) {
7227 mbs.param[0] = MBOX_GET_TARGET_PARAMS;
7229 } else if (sdp->isp_devparam[tgt].dev_update) {
7230 mbs.param[0] = MBOX_SET_TARGET_PARAMS;
7233 * Make sure goal_flags has "Renegotiate on Error"
7234 * on and "Freeze Queue on Error" off.
7236 sdp->isp_devparam[tgt].goal_flags |= DPARM_RENEG;
7237 sdp->isp_devparam[tgt].goal_flags &= ~DPARM_QFRZ;
7238 mbs.param[2] = sdp->isp_devparam[tgt].goal_flags;
7241 * Insist that PARITY must be enabled
7242 * if SYNC or WIDE is enabled.
7244 if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) {
7245 mbs.param[2] |= DPARM_PARITY;
7248 if (mbs.param[2] & DPARM_SYNC) {
7250 (sdp->isp_devparam[tgt].goal_offset << 8) |
7251 (sdp->isp_devparam[tgt].goal_period);
7254 * A command completion later that has
7255 * RQSTF_NEGOTIATION set can cause
7256 * the dev_refresh/announce cycle also.
7258 * Note: It is really important to update our current
7259 * flags with at least the state of TAG capabilities-
7260 * otherwise we might try and send a tagged command
7261 * when we have it all turned off. So change it here
7262 * to say that current already matches goal.
7264 sdp->isp_devparam[tgt].actv_flags &= ~DPARM_TQING;
7265 sdp->isp_devparam[tgt].actv_flags |=
7266 (sdp->isp_devparam[tgt].goal_flags & DPARM_TQING);
7267 isp_prt(isp, ISP_LOGDEBUG0, "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
7268 chan, tgt, mbs.param[2], mbs.param[3] >> 8, mbs.param[3] & 0xff);
7273 mbs.param[1] = (chan << 15) | (tgt << 8);
7274 isp_mboxcmd(isp, &mbs);
7275 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
7279 sdp->sendmarker = 1;
7280 sdp->isp_devparam[tgt].dev_update = 0;
7281 sdp->isp_devparam[tgt].dev_refresh = 1;
7283 sdp->isp_devparam[tgt].dev_refresh = 0;
7284 flags = mbs.param[2];
7285 period = mbs.param[3] & 0xff;
7286 offset = mbs.param[3] >> 8;
7287 sdp->isp_devparam[tgt].actv_flags = flags;
7288 sdp->isp_devparam[tgt].actv_period = period;
7289 sdp->isp_devparam[tgt].actv_offset = offset;
7290 isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, chan, tgt);
7294 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7295 if (sdp->isp_devparam[tgt].dev_update ||
7296 sdp->isp_devparam[tgt].dev_refresh) {
7304 isp_setdfltsdparm(ispsoftc_t *isp)
7307 sdparam *sdp, *sdp1;
7309 sdp = SDPARAM(isp, 0);
7310 if (IS_DUALBUS(isp))
7316 * Establish some default parameters.
7318 sdp->isp_cmd_dma_burst_enable = 0;
7319 sdp->isp_data_dma_burst_enabl = 1;
7320 sdp->isp_fifo_threshold = 0;
7321 sdp->isp_initiator_id = DEFAULT_IID(isp, 0);
7322 if (isp->isp_type >= ISP_HA_SCSI_1040) {
7323 sdp->isp_async_data_setup = 9;
7325 sdp->isp_async_data_setup = 6;
7327 sdp->isp_selection_timeout = 250;
7328 sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
7329 sdp->isp_tag_aging = 8;
7330 sdp->isp_bus_reset_delay = 5;
7332 * Don't retry selection, busy or queue full automatically- reflect
7335 sdp->isp_retry_count = 0;
7336 sdp->isp_retry_delay = 0;
7338 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7339 sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE;
7340 sdp->isp_devparam[tgt].dev_enable = 1;
7344 * The trick here is to establish a default for the default (honk!)
7345 * state (goal_flags). Then try and get the current status from
7346 * the card to fill in the current state. We don't, in fact, set
7347 * the default to the SAFE default state- that's not the goal state.
7349 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7351 sdp->isp_devparam[tgt].actv_offset = 0;
7352 sdp->isp_devparam[tgt].actv_period = 0;
7353 sdp->isp_devparam[tgt].actv_flags = 0;
7355 sdp->isp_devparam[tgt].goal_flags =
7356 sdp->isp_devparam[tgt].nvrm_flags = DPARM_DEFAULT;
7359 * We default to Wide/Fast for versions less than a 1040
7360 * (unless it's SBus).
7362 if (IS_ULTRA3(isp)) {
7363 off = ISP_80M_SYNCPARMS >> 8;
7364 per = ISP_80M_SYNCPARMS & 0xff;
7365 } else if (IS_ULTRA2(isp)) {
7366 off = ISP_40M_SYNCPARMS >> 8;
7367 per = ISP_40M_SYNCPARMS & 0xff;
7368 } else if (IS_1240(isp)) {
7369 off = ISP_20M_SYNCPARMS >> 8;
7370 per = ISP_20M_SYNCPARMS & 0xff;
7371 } else if ((isp->isp_bustype == ISP_BT_SBUS &&
7372 isp->isp_type < ISP_HA_SCSI_1020A) ||
7373 (isp->isp_bustype == ISP_BT_PCI &&
7374 isp->isp_type < ISP_HA_SCSI_1040) ||
7375 (isp->isp_clock && isp->isp_clock < 60) ||
7376 (sdp->isp_ultramode == 0)) {
7377 off = ISP_10M_SYNCPARMS >> 8;
7378 per = ISP_10M_SYNCPARMS & 0xff;
7380 off = ISP_20M_SYNCPARMS_1040 >> 8;
7381 per = ISP_20M_SYNCPARMS_1040 & 0xff;
7383 sdp->isp_devparam[tgt].goal_offset =
7384 sdp->isp_devparam[tgt].nvrm_offset = off;
7385 sdp->isp_devparam[tgt].goal_period =
7386 sdp->isp_devparam[tgt].nvrm_period = per;
7391 * If we're a dual bus card, just copy the data over
7395 sdp1->isp_initiator_id = DEFAULT_IID(isp, 1);
7399 * If we've not been told to avoid reading NVRAM, try and read it.
7400 * If we're successful reading it, we can then return because NVRAM
7401 * will tell us what the desired settings are. Otherwise, we establish
7402 * some reasonable 'fake' nvram and goal defaults.
7404 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7407 if (isp_read_nvram(isp, 0) == 0) {
7408 if (IS_DUALBUS(isp)) {
7409 if (isp_read_nvram(isp, 1) == 0) {
7414 MBSINIT(&mbs, MBOX_GET_ACT_NEG_STATE, MBLOGNONE, 0);
7415 isp_mboxcmd(isp, &mbs);
7416 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
7417 sdp->isp_req_ack_active_neg = 1;
7418 sdp->isp_data_line_active_neg = 1;
7420 sdp1->isp_req_ack_active_neg = 1;
7421 sdp1->isp_data_line_active_neg = 1;
7424 sdp->isp_req_ack_active_neg =
7425 (mbs.param[1] >> 4) & 0x1;
7426 sdp->isp_data_line_active_neg =
7427 (mbs.param[1] >> 5) & 0x1;
7429 sdp1->isp_req_ack_active_neg =
7430 (mbs.param[2] >> 4) & 0x1;
7431 sdp1->isp_data_line_active_neg =
7432 (mbs.param[2] >> 5) & 0x1;
7440 isp_setdfltfcparm(ispsoftc_t *isp, int chan)
7442 fcparam *fcp = FCPARAM(isp, chan);
7445 * Establish some default parameters.
7447 fcp->role = DEFAULT_ROLE(isp, chan);
7448 fcp->isp_maxalloc = ICB_DFLT_ALLOC;
7449 fcp->isp_retry_delay = ICB_DFLT_RDELAY;
7450 fcp->isp_retry_count = ICB_DFLT_RCOUNT;
7451 fcp->isp_loopid = DEFAULT_LOOPID(isp, chan);
7452 fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp, chan);
7453 fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp, chan);
7454 fcp->isp_fwoptions = 0;
7455 fcp->isp_xfwoptions = 0;
7456 fcp->isp_zfwoptions = 0;
7457 fcp->isp_lasthdl = NIL_HANDLE;
7458 fcp->isp_login_hdl = NIL_HANDLE;
7461 fcp->isp_fwoptions |= ICB2400_OPT1_FAIRNESS;
7462 fcp->isp_fwoptions |= ICB2400_OPT1_HARD_ADDRESS;
7463 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
7464 fcp->isp_fwoptions |= ICB2400_OPT1_FULL_DUPLEX;
7465 fcp->isp_fwoptions |= ICB2400_OPT1_BOTH_WWNS;
7466 fcp->isp_xfwoptions |= ICB2400_OPT2_LOOP_2_PTP;
7467 fcp->isp_zfwoptions |= ICB2400_OPT3_RATE_AUTO;
7469 fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
7470 fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
7471 fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
7472 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
7473 fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
7475 * Make sure this is turned off now until we get
7476 * extended options from NVRAM
7478 fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
7479 fcp->isp_xfwoptions |= ICBXOPT_LOOP_2_PTP;
7480 fcp->isp_zfwoptions |= ICBZOPT_RATE_AUTO;
7485 * Now try and read NVRAM unless told to not do so.
7486 * This will set fcparam's isp_wwnn_nvram && isp_wwpn_nvram.
7488 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7491 * Give a couple of tries at reading NVRAM.
7493 for (i = 0; i < 2; i++) {
7494 j = isp_read_nvram(isp, chan);
7500 isp->isp_confopts |= ISP_CFG_NONVRAM;
7504 fcp->isp_wwnn = ACTIVE_NODEWWN(isp, chan);
7505 fcp->isp_wwpn = ACTIVE_PORTWWN(isp, chan);
7506 isp_prt(isp, ISP_LOGCONFIG, "Chan %d 0x%08x%08x/0x%08x%08x Role %s",
7507 chan, (uint32_t) (fcp->isp_wwnn >> 32), (uint32_t) (fcp->isp_wwnn),
7508 (uint32_t) (fcp->isp_wwpn >> 32), (uint32_t) (fcp->isp_wwpn),
7509 isp_class3_roles[fcp->role]);
7513 * Re-initialize the ISP and complete all orphaned commands
7514 * with a 'botched' notice. The reset/init routines should
7515 * not disturb an already active list of commands.
7519 isp_reinit(ispsoftc_t *isp, int do_load_defaults)
7523 if (isp->isp_state > ISP_RESETSTATE)
7525 if (isp->isp_state != ISP_RESETSTATE)
7526 isp_reset(isp, do_load_defaults);
7527 if (isp->isp_state != ISP_RESETSTATE) {
7529 isp_prt(isp, ISP_LOGERR, "%s: cannot reset card", __func__);
7534 if (isp->isp_state > ISP_RESETSTATE &&
7535 isp->isp_state != ISP_RUNSTATE) {
7537 isp_prt(isp, ISP_LOGERR, "%s: cannot init card", __func__);
7538 ISP_DISABLE_INTS(isp);
7541 * If we're in ISP_ROLE_NONE, turn off the lasers.
7543 if (!IS_24XX(isp)) {
7544 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
7545 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
7546 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
7547 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
7548 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
7554 isp_clear_commands(isp);
7556 for (i = 0; i < isp->isp_nchan; i++)
7557 isp_clear_portdb(isp, i);
7566 isp_read_nvram(ispsoftc_t *isp, int bus)
7569 uint8_t csum, minversion;
7571 uint8_t _x[ISP2400_NVRAM_SIZE];
7572 uint16_t _s[ISP2400_NVRAM_SIZE>>1];
7574 #define nvram_data _n._x
7575 #define nvram_words _n._s
7578 return (isp_read_nvram_2400(isp, nvram_data));
7579 } else if (IS_FC(isp)) {
7580 amt = ISP2100_NVRAM_SIZE;
7582 } else if (IS_ULTRA2(isp)) {
7583 amt = ISP1080_NVRAM_SIZE;
7586 amt = ISP_NVRAM_SIZE;
7590 for (i = 0; i < amt>>1; i++) {
7591 isp_rdnvram_word(isp, i, &nvram_words[i]);
7594 if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7595 nvram_data[2] != 'P') {
7596 if (isp->isp_bustype != ISP_BT_SBUS) {
7597 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
7598 isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x", nvram_data[0], nvram_data[1], nvram_data[2]);
7604 for (csum = 0, i = 0; i < amt; i++) {
7605 csum += nvram_data[i];
7608 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7613 if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
7614 isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
7615 ISP_NVRAM_VERSION(nvram_data));
7620 if (IS_ULTRA3(isp)) {
7621 isp_parse_nvram_12160(isp, bus, nvram_data);
7622 } else if (IS_1080(isp)) {
7623 isp_parse_nvram_1080(isp, bus, nvram_data);
7624 } else if (IS_1280(isp) || IS_1240(isp)) {
7625 isp_parse_nvram_1080(isp, bus, nvram_data);
7626 } else if (IS_SCSI(isp)) {
7627 isp_parse_nvram_1020(isp, nvram_data);
7629 isp_parse_nvram_2100(isp, nvram_data);
7639 isp_read_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
7642 uint32_t addr, csum, lwrds, *dptr;
7644 if (isp->isp_port) {
7645 addr = ISP2400_NVRAM_PORT1_ADDR;
7647 addr = ISP2400_NVRAM_PORT0_ADDR;
7650 dptr = (uint32_t *) nvram_data;
7651 for (lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7652 isp_rd_2400_nvram(isp, addr++, dptr++);
7654 if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7655 nvram_data[2] != 'P') {
7656 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header (%x %x %x)",
7657 nvram_data[0], nvram_data[1], nvram_data[2]);
7661 dptr = (uint32_t *) nvram_data;
7662 for (csum = 0, lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7664 ISP_IOXGET_32(isp, &dptr[lwrds], tmp);
7668 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7672 isp_parse_nvram_2400(isp, nvram_data);
7678 isp_rdnvram_word(ispsoftc_t *isp, int wo, uint16_t *rp)
7681 uint16_t bit, rqst, junk;
7683 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7685 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7689 wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
7690 if (IS_2312(isp) && isp->isp_port) {
7693 rqst = (ISP_NVRAM_READ << 8) | wo;
7695 } else if (IS_ULTRA2(isp)) {
7696 wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1);
7697 rqst = (ISP_NVRAM_READ << 8) | wo;
7700 wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
7701 rqst = (ISP_NVRAM_READ << 6) | wo;
7706 * Clock the word select request out...
7708 for (i = cbits; i >= 0; i--) {
7709 if ((rqst >> i) & 1) {
7710 bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
7712 bit = BIU_NVRAM_SELECT;
7714 ISP_WRITE(isp, BIU_NVRAM, bit);
7716 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7717 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
7719 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7720 ISP_WRITE(isp, BIU_NVRAM, bit);
7722 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7725 * Now read the result back in (bits come back in MSB format).
7728 for (i = 0; i < 16; i++) {
7731 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7733 rv = ISP_READ(isp, BIU_NVRAM);
7734 if (rv & BIU_NVRAM_DATAIN) {
7738 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7740 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7742 ISP_WRITE(isp, BIU_NVRAM, 0);
7744 junk = ISP_READ(isp, BIU_NVRAM); /* force PCI flush */
7745 ISP_SWIZZLE_NVRAM_WORD(isp, rp);
7749 isp_rd_2400_nvram(ispsoftc_t *isp, uint32_t addr, uint32_t *rp)
7752 uint32_t base = 0x7ffe0000;
7756 base = 0x7fe7c000; /* XXX: Observation, may be wrong. */
7757 } else if (IS_25XX(isp)) {
7758 base = 0x7ff00000 | 0x48000;
7760 ISP_WRITE(isp, BIU2400_FLASH_ADDR, base | addr);
7761 for (loops = 0; loops < 5000; loops++) {
7763 tmp = ISP_READ(isp, BIU2400_FLASH_ADDR);
7764 if ((tmp & (1U << 31)) != 0) {
7768 if (tmp & (1U << 31)) {
7769 *rp = ISP_READ(isp, BIU2400_FLASH_DATA);
7770 ISP_SWIZZLE_NVRAM_LONG(isp, rp);
7777 isp_parse_nvram_1020(ispsoftc_t *isp, uint8_t *nvram_data)
7779 sdparam *sdp = SDPARAM(isp, 0);
7782 sdp->isp_fifo_threshold =
7783 ISP_NVRAM_FIFO_THRESHOLD(nvram_data) |
7784 (ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2);
7786 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7787 sdp->isp_initiator_id = ISP_NVRAM_INITIATOR_ID(nvram_data);
7789 sdp->isp_bus_reset_delay =
7790 ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
7792 sdp->isp_retry_count =
7793 ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
7795 sdp->isp_retry_delay =
7796 ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
7798 sdp->isp_async_data_setup =
7799 ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
7801 if (isp->isp_type >= ISP_HA_SCSI_1040) {
7802 if (sdp->isp_async_data_setup < 9) {
7803 sdp->isp_async_data_setup = 9;
7806 if (sdp->isp_async_data_setup != 6) {
7807 sdp->isp_async_data_setup = 6;
7811 sdp->isp_req_ack_active_neg =
7812 ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
7814 sdp->isp_data_line_active_neg =
7815 ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
7817 sdp->isp_data_dma_burst_enabl =
7818 ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
7820 sdp->isp_cmd_dma_burst_enable =
7821 ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
7823 sdp->isp_tag_aging =
7824 ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
7826 sdp->isp_selection_timeout =
7827 ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
7829 sdp->isp_max_queue_depth =
7830 ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
7832 sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
7834 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7835 sdp->isp_devparam[tgt].dev_enable =
7836 ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt);
7837 sdp->isp_devparam[tgt].exc_throttle =
7838 ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt);
7839 sdp->isp_devparam[tgt].nvrm_offset =
7840 ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt);
7841 sdp->isp_devparam[tgt].nvrm_period =
7842 ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt);
7844 * We probably shouldn't lie about this, but it
7845 * it makes it much safer if we limit NVRAM values
7848 if (isp->isp_type < ISP_HA_SCSI_1040) {
7850 * If we're not ultra, we can't possibly
7851 * be a shorter period than this.
7853 if (sdp->isp_devparam[tgt].nvrm_period < 0x19) {
7854 sdp->isp_devparam[tgt].nvrm_period = 0x19;
7856 if (sdp->isp_devparam[tgt].nvrm_offset > 0xc) {
7857 sdp->isp_devparam[tgt].nvrm_offset = 0x0c;
7860 if (sdp->isp_devparam[tgt].nvrm_offset > 0x8) {
7861 sdp->isp_devparam[tgt].nvrm_offset = 0x8;
7864 sdp->isp_devparam[tgt].nvrm_flags = 0;
7865 if (ISP_NVRAM_TGT_RENEG(nvram_data, tgt))
7866 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7867 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7868 if (ISP_NVRAM_TGT_TQING(nvram_data, tgt))
7869 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7870 if (ISP_NVRAM_TGT_SYNC(nvram_data, tgt))
7871 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7872 if (ISP_NVRAM_TGT_WIDE(nvram_data, tgt))
7873 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7874 if (ISP_NVRAM_TGT_PARITY(nvram_data, tgt))
7875 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7876 if (ISP_NVRAM_TGT_DISC(nvram_data, tgt))
7877 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7878 sdp->isp_devparam[tgt].actv_flags = 0; /* we don't know */
7879 sdp->isp_devparam[tgt].goal_offset =
7880 sdp->isp_devparam[tgt].nvrm_offset;
7881 sdp->isp_devparam[tgt].goal_period =
7882 sdp->isp_devparam[tgt].nvrm_period;
7883 sdp->isp_devparam[tgt].goal_flags =
7884 sdp->isp_devparam[tgt].nvrm_flags;
7889 isp_parse_nvram_1080(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7891 sdparam *sdp = SDPARAM(isp, bus);
7894 sdp->isp_fifo_threshold =
7895 ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data);
7897 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7898 sdp->isp_initiator_id = ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus);
7900 sdp->isp_bus_reset_delay =
7901 ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7903 sdp->isp_retry_count =
7904 ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7906 sdp->isp_retry_delay =
7907 ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7909 sdp->isp_async_data_setup =
7910 ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7912 sdp->isp_req_ack_active_neg =
7913 ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7915 sdp->isp_data_line_active_neg =
7916 ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7918 sdp->isp_data_dma_burst_enabl =
7919 ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7921 sdp->isp_cmd_dma_burst_enable =
7922 ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7924 sdp->isp_selection_timeout =
7925 ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
7927 sdp->isp_max_queue_depth =
7928 ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
7930 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7931 sdp->isp_devparam[tgt].dev_enable =
7932 ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
7933 sdp->isp_devparam[tgt].exc_throttle =
7934 ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
7935 sdp->isp_devparam[tgt].nvrm_offset =
7936 ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
7937 sdp->isp_devparam[tgt].nvrm_period =
7938 ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
7939 sdp->isp_devparam[tgt].nvrm_flags = 0;
7940 if (ISP1080_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
7941 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7942 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7943 if (ISP1080_NVRAM_TGT_TQING(nvram_data, tgt, bus))
7944 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7945 if (ISP1080_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
7946 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7947 if (ISP1080_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
7948 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7949 if (ISP1080_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
7950 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7951 if (ISP1080_NVRAM_TGT_DISC(nvram_data, tgt, bus))
7952 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7953 sdp->isp_devparam[tgt].actv_flags = 0;
7954 sdp->isp_devparam[tgt].goal_offset =
7955 sdp->isp_devparam[tgt].nvrm_offset;
7956 sdp->isp_devparam[tgt].goal_period =
7957 sdp->isp_devparam[tgt].nvrm_period;
7958 sdp->isp_devparam[tgt].goal_flags =
7959 sdp->isp_devparam[tgt].nvrm_flags;
7964 isp_parse_nvram_12160(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7966 sdparam *sdp = SDPARAM(isp, bus);
7969 sdp->isp_fifo_threshold =
7970 ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data);
7972 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7973 sdp->isp_initiator_id = ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus);
7975 sdp->isp_bus_reset_delay =
7976 ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7978 sdp->isp_retry_count =
7979 ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7981 sdp->isp_retry_delay =
7982 ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7984 sdp->isp_async_data_setup =
7985 ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7987 sdp->isp_req_ack_active_neg =
7988 ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7990 sdp->isp_data_line_active_neg =
7991 ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7993 sdp->isp_data_dma_burst_enabl =
7994 ISP12160_NVRAM_BURST_ENABLE(nvram_data);
7996 sdp->isp_cmd_dma_burst_enable =
7997 ISP12160_NVRAM_BURST_ENABLE(nvram_data);
7999 sdp->isp_selection_timeout =
8000 ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
8002 sdp->isp_max_queue_depth =
8003 ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
8005 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
8006 sdp->isp_devparam[tgt].dev_enable =
8007 ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
8008 sdp->isp_devparam[tgt].exc_throttle =
8009 ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
8010 sdp->isp_devparam[tgt].nvrm_offset =
8011 ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
8012 sdp->isp_devparam[tgt].nvrm_period =
8013 ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
8014 sdp->isp_devparam[tgt].nvrm_flags = 0;
8015 if (ISP12160_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
8016 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
8017 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
8018 if (ISP12160_NVRAM_TGT_TQING(nvram_data, tgt, bus))
8019 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
8020 if (ISP12160_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
8021 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
8022 if (ISP12160_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
8023 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
8024 if (ISP12160_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
8025 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
8026 if (ISP12160_NVRAM_TGT_DISC(nvram_data, tgt, bus))
8027 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
8028 sdp->isp_devparam[tgt].actv_flags = 0;
8029 sdp->isp_devparam[tgt].goal_offset =
8030 sdp->isp_devparam[tgt].nvrm_offset;
8031 sdp->isp_devparam[tgt].goal_period =
8032 sdp->isp_devparam[tgt].nvrm_period;
8033 sdp->isp_devparam[tgt].goal_flags =
8034 sdp->isp_devparam[tgt].nvrm_flags;
8039 isp_parse_nvram_2100(ispsoftc_t *isp, uint8_t *nvram_data)
8041 fcparam *fcp = FCPARAM(isp, 0);
8045 * There is NVRAM storage for both Port and Node entities-
8046 * but the Node entity appears to be unused on all the cards
8047 * I can find. However, we should account for this being set
8048 * at some point in the future.
8050 * Qlogic WWNs have an NAA of 2, but usually nothing shows up in
8051 * bits 48..60. In the case of the 2202, it appears that they do
8052 * use bit 48 to distinguish between the two instances on the card.
8053 * The 2204, which I've never seen, *probably* extends this method.
8055 wwn = ISP2100_NVRAM_PORT_NAME(nvram_data);
8057 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
8058 (uint32_t) (wwn >> 32), (uint32_t) (wwn));
8059 if ((wwn >> 60) == 0) {
8060 wwn |= (((uint64_t) 2)<< 60);
8063 fcp->isp_wwpn_nvram = wwn;
8064 if (IS_2200(isp) || IS_23XX(isp)) {
8065 wwn = ISP2100_NVRAM_NODE_NAME(nvram_data);
8067 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
8068 (uint32_t) (wwn >> 32),
8070 if ((wwn >> 60) == 0) {
8071 wwn |= (((uint64_t) 2)<< 60);
8074 wwn = fcp->isp_wwpn_nvram & ~((uint64_t) 0xfff << 48);
8077 wwn &= ~((uint64_t) 0xfff << 48);
8079 fcp->isp_wwnn_nvram = wwn;
8081 fcp->isp_maxalloc = ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
8082 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8083 DEFAULT_FRAMESIZE(isp) =
8084 ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
8086 fcp->isp_retry_delay = ISP2100_NVRAM_RETRY_DELAY(nvram_data);
8087 fcp->isp_retry_count = ISP2100_NVRAM_RETRY_COUNT(nvram_data);
8088 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8089 fcp->isp_loopid = ISP2100_NVRAM_HARDLOOPID(nvram_data);
8091 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8092 DEFAULT_EXEC_THROTTLE(isp) =
8093 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
8095 fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
8096 isp_prt(isp, ISP_LOGDEBUG0,
8097 "NVRAM 0x%08x%08x 0x%08x%08x maxalloc %d maxframelen %d",
8098 (uint32_t) (fcp->isp_wwnn_nvram >> 32),
8099 (uint32_t) fcp->isp_wwnn_nvram,
8100 (uint32_t) (fcp->isp_wwpn_nvram >> 32),
8101 (uint32_t) fcp->isp_wwpn_nvram,
8102 ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data),
8103 ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data));
8104 isp_prt(isp, ISP_LOGDEBUG0,
8105 "execthrottle %d fwoptions 0x%x hardloop %d tov %d",
8106 ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data),
8107 ISP2100_NVRAM_OPTIONS(nvram_data),
8108 ISP2100_NVRAM_HARDLOOPID(nvram_data),
8109 ISP2100_NVRAM_TOV(nvram_data));
8110 fcp->isp_xfwoptions = ISP2100_XFW_OPTIONS(nvram_data);
8111 fcp->isp_zfwoptions = ISP2100_ZFW_OPTIONS(nvram_data);
8112 isp_prt(isp, ISP_LOGDEBUG0, "xfwoptions 0x%x zfw options 0x%x",
8113 ISP2100_XFW_OPTIONS(nvram_data), ISP2100_ZFW_OPTIONS(nvram_data));
8117 isp_parse_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
8119 fcparam *fcp = FCPARAM(isp, 0);
8122 isp_prt(isp, ISP_LOGDEBUG0,
8123 "NVRAM 0x%08x%08x 0x%08x%08x exchg_cnt %d maxframelen %d",
8124 (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data) >> 32),
8125 (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data)),
8126 (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data) >> 32),
8127 (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data)),
8128 ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data),
8129 ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data));
8130 isp_prt(isp, ISP_LOGDEBUG0,
8131 "NVRAM execthr %d loopid %d fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
8132 ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data),
8133 ISP2400_NVRAM_HARDLOOPID(nvram_data),
8134 ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data),
8135 ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data),
8136 ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data));
8138 wwn = ISP2400_NVRAM_PORT_NAME(nvram_data);
8139 fcp->isp_wwpn_nvram = wwn;
8141 wwn = ISP2400_NVRAM_NODE_NAME(nvram_data);
8143 if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
8147 if (wwn == 0 && (fcp->isp_wwpn_nvram >> 60) == 2) {
8148 wwn = fcp->isp_wwpn_nvram;
8149 wwn &= ~((uint64_t) 0xfff << 48);
8151 fcp->isp_wwnn_nvram = wwn;
8153 if (ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data)) {
8154 fcp->isp_maxalloc = ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data);
8156 if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8157 DEFAULT_FRAMESIZE(isp) =
8158 ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data);
8160 if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8161 fcp->isp_loopid = ISP2400_NVRAM_HARDLOOPID(nvram_data);
8163 if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8164 DEFAULT_EXEC_THROTTLE(isp) =
8165 ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data);
8167 fcp->isp_fwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data);
8168 fcp->isp_xfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data);
8169 fcp->isp_zfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data);