sys/dev/isp/isp.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  *  Copyright (c) 2009-2020 Alexander Motin <mav@FreeBSD.org>
   5  *  Copyright (c) 1997-2009 by Matthew Jacob
   6  *  All rights reserved.
   7  *
   8  *  Redistribution and use in source and binary forms, with or without
   9  *  modification, are permitted provided that the following conditions
  10  *  are met:
  11  *
  12  *  1. Redistributions of source code must retain the above copyright
  13  *     notice, this list of conditions and the following disclaimer.
  14  *  2. Redistributions in binary form must reproduce the above copyright
  15  *     notice, this list of conditions and the following disclaimer in the
  16  *     documentation and/or other materials provided with the distribution.
  17  *
  18  *  THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  *  ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  22  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  *  SUCH DAMAGE.
  29  *
  30  */
  31
  32 /*
  33  * Machine and OS Independent (well, as best as possible)
  34  * code for the Qlogic ISP SCSI and FC-SCSI adapters.
  35  */
  36
  37 /*
  38  * Inspiration and ideas about this driver are from Erik Moe's Linux driver
  39  * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
  40  * ideas dredged from the Solaris driver.
  41  */
  42
  43 /*
  44  * Include header file appropriate for platform we're building on.
  45  */
  46 #ifdef  __NetBSD__
  47 #include <sys/cdefs.h>
  48 __KERNEL_RCSID(0, "$NetBSD$");
  49 #include <dev/ic/isp_netbsd.h>
  50 #endif
  51 #ifdef  __FreeBSD__
  52 #include <sys/cdefs.h>
  53 __FBSDID("$FreeBSD$");
  54 #include <dev/isp/isp_freebsd.h>
  55 #endif
  56 #ifdef  __OpenBSD__
  57 #include <dev/ic/isp_openbsd.h>
  58 #endif
  59 #ifdef  __linux__
  60 #include "isp_linux.h"
  61 #endif
  62 #ifdef  __svr4__
  63 #include "isp_solaris.h"
  64 #endif
  65
  66 /*
  67  * Local static data
  68  */
  69 static const char notresp[] = "Unknown IOCB in RESPONSE Queue (type 0x%x) @ idx %d (next %d)";
  70 static const char bun[] = "bad underrun (count %d, resid %d, status %s)";
  71 static const char lipd[] = "Chan %d LIP destroyed %d active commands";
  72 static const char sacq[] = "unable to acquire scratch area";
  73
  74 static const uint8_t alpa_map[] = {
  75         0xef, 0xe8, 0xe4, 0xe2, 0xe1, 0xe0, 0xdc, 0xda,
  76         0xd9, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xce,
  77         0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc7, 0xc6, 0xc5,
  78         0xc3, 0xbc, 0xba, 0xb9, 0xb6, 0xb5, 0xb4, 0xb3,
  79         0xb2, 0xb1, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9,
  80         0xa7, 0xa6, 0xa5, 0xa3, 0x9f, 0x9e, 0x9d, 0x9b,
  81         0x98, 0x97, 0x90, 0x8f, 0x88, 0x84, 0x82, 0x81,
  82         0x80, 0x7c, 0x7a, 0x79, 0x76, 0x75, 0x74, 0x73,
  83         0x72, 0x71, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69,
  84         0x67, 0x66, 0x65, 0x63, 0x5c, 0x5a, 0x59, 0x56,
  85         0x55, 0x54, 0x53, 0x52, 0x51, 0x4e, 0x4d, 0x4c,
  86         0x4b, 0x4a, 0x49, 0x47, 0x46, 0x45, 0x43, 0x3c,
  87         0x3a, 0x39, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31,
  88         0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x27, 0x26,
  89         0x25, 0x23, 0x1f, 0x1e, 0x1d, 0x1b, 0x18, 0x17,
  90         0x10, 0x0f, 0x08, 0x04, 0x02, 0x01, 0x00
  91 };
  92
  93 /*
  94  * Local function prototypes.
  95  */
  96 static int isp_handle_control(ispsoftc_t *, isphdr_t *);
  97 static void isp_handle_rpt_id_acq(ispsoftc_t *, isphdr_t *);
  98 static void isp_parse_status_24xx(ispsoftc_t *, isp24xx_statusreq_t *, XS_T *);
  99 static void isp_clear_portdb(ispsoftc_t *, int);
 100 static void isp_mark_portdb(ispsoftc_t *, int);
 101 static int isp_plogx(ispsoftc_t *, int, uint16_t, uint32_t, int);
 102 static int isp_getpdb(ispsoftc_t *, int, uint16_t, isp_pdb_t *);
 103 static int isp_gethandles(ispsoftc_t *, int, uint16_t *, int *, int);
 104 static void isp_dump_chip_portdb(ispsoftc_t *, int);
 105 static uint64_t isp_get_wwn(ispsoftc_t *, int, int, int);
 106 static int isp_fclink_test(ispsoftc_t *, int, int);
 107 static int isp_pdb_sync(ispsoftc_t *, int);
 108 static int isp_scan_loop(ispsoftc_t *, int);
 109 static int isp_gid_pt(ispsoftc_t *, int);
 110 static int isp_scan_fabric(ispsoftc_t *, int);
 111 static int isp_login_device(ispsoftc_t *, int, uint32_t, isp_pdb_t *, uint16_t *);
 112 static int isp_register_fc4_type(ispsoftc_t *, int);
 113 static int isp_register_fc4_features_24xx(ispsoftc_t *, int);
 114 static int isp_register_port_name_24xx(ispsoftc_t *, int);
 115 static int isp_register_node_name_24xx(ispsoftc_t *, int);
 116 static uint16_t isp_next_handle(ispsoftc_t *, uint16_t *);
 117 static int isp_fw_state(ispsoftc_t *, int);
 118 static void isp_mboxcmd(ispsoftc_t *, mbreg_t *);
 119
 120 static void isp_setdfltfcparm(ispsoftc_t *, int);
 121 static int isp_read_nvram(ispsoftc_t *, int);
 122 static int isp_read_nvram_2400(ispsoftc_t *);
 123 static void isp_rd_2400_nvram(ispsoftc_t *, uint32_t, uint32_t *);
 124 static void isp_parse_nvram_2400(ispsoftc_t *, uint8_t *);
 125
 126 static void
 127 isp_change_fw_state(ispsoftc_t *isp, int chan, int state)
 128 {
 129         fcparam *fcp = FCPARAM(isp, chan);
 130
 131         if (fcp->isp_fwstate == state)
 132                 return;
 133         isp_prt(isp, ISP_LOGCONFIG|ISP_LOG_SANCFG,
 134             "Chan %d Firmware state <%s->%s>", chan,
 135             isp_fc_fw_statename(fcp->isp_fwstate), isp_fc_fw_statename(state));
 136         fcp->isp_fwstate = state;
 137 }
 138
 139 /*
 140  * Reset Hardware.
 141  *
 142  * Hit the chip over the head, download new f/w if available and set it running.
 143  *
 144  * Locking done elsewhere.
 145  */
 146
 147 void
 148 isp_reset(ispsoftc_t *isp, int do_load_defaults)
 149 {
 150         mbreg_t mbs;
 151         char *buf;
 152         uint64_t fwt;
 153         uint32_t code_org, val;
 154         int loaded_fw, loops, i, dodnld = 1;
 155         const char *btype = "????";
 156         static const char dcrc[] = "Downloaded RISC Code Checksum Failure";
 157
 158         isp->isp_state = ISP_NILSTATE;
 159         ISP_DISABLE_INTS(isp);
 160
 161         /*
 162          * Put the board into PAUSE mode (so we can read the SXP registers
 163          * or write FPM/FBM registers).
 164          */
 165         ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_HOST_INT);
 166         ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
 167         ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
 168
 169         switch (isp->isp_type) {
 170         case ISP_HA_FC_2400:
 171                 btype = "2422";
 172                 break;
 173         case ISP_HA_FC_2500:
 174                 btype = "2532";
 175                 break;
 176         case ISP_HA_FC_2600:
 177                 btype = "2600";
 178                 break;
 179         case ISP_HA_FC_2700:
 180                 btype = "2700";
 181                 break;
 182         default:
 183                 break;
 184         }
 185
 186         /*
 187          * Stop DMA and wait for it to stop.
 188          */
 189         ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
 190         for (loops = 0; loops < 100000; loops++) {
 191                 ISP_DELAY(10);
 192                 val = ISP_READ(isp, BIU2400_CSR);
 193                 if ((val & BIU2400_DMA_ACTIVE) == 0) {
 194                         break;
 195                 }
 196         }
 197         if (val & BIU2400_DMA_ACTIVE)
 198                 isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
 199
 200         /*
 201          * Hold it in SOFT_RESET and STOP state for 100us.
 202          */
 203         ISP_WRITE(isp, BIU2400_CSR, BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
 204         ISP_DELAY(100);
 205         for (loops = 0; loops < 10000; loops++) {
 206                 ISP_DELAY(5);
 207                 val = ISP_READ(isp, OUTMAILBOX0);
 208                 if (val != 0x4)
 209                         break;
 210         }
 211         switch (val) {
 212         case 0x0:
 213                 break;
 214         case 0x4:
 215                 isp_prt(isp, ISP_LOGERR, "The ROM code is busy after 50ms.");
 216                 return;
 217         case 0xf:
 218                 isp_prt(isp, ISP_LOGERR, "Board configuration error.");
 219                 return;
 220         default:
 221                 isp_prt(isp, ISP_LOGERR, "Unknown RISC Status Code 0x%x.", val);
 222                 return;
 223         }
 224
 225         /*
 226          * Reset RISC Processor
 227          */
 228         ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
 229         ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
 230         ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
 231
 232         /*
 233          * Post-RISC Reset stuff.
 234          */
 235         for (loops = 0; loops < 10000; loops++) {
 236                 ISP_DELAY(5);
 237                 val = ISP_READ(isp, OUTMAILBOX0);
 238                 if (val != 0x4)
 239                         break;
 240         }
 241         switch (val) {
 242         case 0x0:
 243                 break;
 244         case 0x4:
 245                 isp_prt(isp, ISP_LOGERR, "The ROM code is busy after 50ms.");
 246                 return;
 247         case 0xf:
 248                 isp_prt(isp, ISP_LOGERR, "Board configuration error.");
 249                 return;
 250         default:
 251                 isp_prt(isp, ISP_LOGERR, "Unknown RISC Status Code 0x%x.", val);
 252                 return;
 253         }
 254
 255         isp->isp_reqidx = isp->isp_reqodx = 0;
 256         isp->isp_resodx = 0;
 257         isp->isp_atioodx = 0;
 258         ISP_WRITE(isp, BIU2400_REQINP, 0);
 259         ISP_WRITE(isp, BIU2400_REQOUTP, 0);
 260         ISP_WRITE(isp, BIU2400_RSPINP, 0);
 261         ISP_WRITE(isp, BIU2400_RSPOUTP, 0);
 262         if (!IS_26XX(isp)) {
 263                 ISP_WRITE(isp, BIU2400_PRI_REQINP, 0);
 264                 ISP_WRITE(isp, BIU2400_PRI_REQOUTP, 0);
 265         }
 266         ISP_WRITE(isp, BIU2400_ATIO_RSPINP, 0);
 267         ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, 0);
 268
 269         /*
 270          * Up until this point we've done everything by just reading or
 271          * setting registers. From this point on we rely on at least *some*
 272          * kind of firmware running in the card.
 273          */
 274
 275         /*
 276          * Do some sanity checking by running a NOP command.
 277          * If it succeeds, the ROM firmware is now running.
 278          */
 279         MBSINIT(&mbs, MBOX_NO_OP, MBLOGALL, 0);
 280         isp_mboxcmd(isp, &mbs);
 281         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 282                 isp_prt(isp, ISP_LOGERR, "NOP command failed (%x)", mbs.param[0]);
 283                 return;
 284         }
 285
 286         /*
 287          * Do some operational tests
 288          */
 289         {
 290                 static const uint16_t patterns[MAX_MAILBOX] = {
 291                         0x0000, 0xdead, 0xbeef, 0xffff,
 292                         0xa5a5, 0x5a5a, 0x7f7f, 0x7ff7,
 293                         0x3421, 0xabcd, 0xdcba, 0xfeef,
 294                         0xbead, 0xdebe, 0x2222, 0x3333,
 295                         0x5555, 0x6666, 0x7777, 0xaaaa,
 296                         0xffff, 0xdddd, 0x9999, 0x1fbc,
 297                         0x6666, 0x6677, 0x1122, 0x33ff,
 298                         0x0000, 0x0001, 0x1000, 0x1010,
 299                 };
 300                 int nmbox = ISP_NMBOX(isp);
 301                 MBSINIT(&mbs, MBOX_MAILBOX_REG_TEST, MBLOGALL, 0);
 302                 for (i = 1; i < nmbox; i++) {
 303                         mbs.param[i] = patterns[i];
 304                 }
 305                 isp_mboxcmd(isp, &mbs);
 306                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 307                         return;
 308                 }
 309                 for (i = 1; i < nmbox; i++) {
 310                         if (mbs.param[i] != patterns[i]) {
 311                                 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]);
 312                                 return;
 313                         }
 314                 }
 315         }
 316
 317         /*
 318          * Download new Firmware, unless requested not to do so.
 319          * This is made slightly trickier in some cases where the
 320          * firmware of the ROM revision is newer than the revision
 321          * compiled into the driver. So, where we used to compare
 322          * versions of our f/w and the ROM f/w, now we just see
 323          * whether we have f/w at all and whether a config flag
 324          * has disabled our download.
 325          */
 326         if ((isp->isp_mdvec->dv_ispfw == NULL) || (isp->isp_confopts & ISP_CFG_NORELOAD)) {
 327                 dodnld = 0;
 328         } else {
 329
 330                 /*
 331                  * Set up DMA for the request and response queues.
 332                  * We do this now so we can use the request queue
 333                  * for dma to load firmware from.
 334                  */
 335                 if (ISP_MBOXDMASETUP(isp) != 0) {
 336                         isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
 337                         return;
 338                 }
 339         }
 340
 341         code_org = ISP_CODE_ORG_2400;
 342         loaded_fw = 0;
 343         if (dodnld) {
 344                 const uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
 345                 uint32_t la, wi, wl;
 346
 347                 /*
 348                  * Keep loading until we run out of f/w.
 349                  */
 350                 code_org = ptr[2];      /* 1st load address is our start addr */
 351                 for (;;) {
 352                         isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], ptr[2]);
 353
 354                         wi = 0;
 355                         la = ptr[2];
 356                         wl = ptr[3];
 357                         while (wi < ptr[3]) {
 358                                 uint32_t *cp;
 359                                 uint32_t nw;
 360
 361                                 nw = min(wl, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) / 4);
 362                                 cp = isp->isp_rquest;
 363                                 for (i = 0; i < nw; i++)
 364                                         ISP_IOXPUT_32(isp, ptr[wi + i], &cp[i]);
 365                                 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
 366                                 MBSINIT(&mbs, MBOX_LOAD_RISC_RAM, MBLOGALL, 0);
 367                                 mbs.param[1] = la;
 368                                 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
 369                                 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
 370                                 mbs.param[4] = nw >> 16;
 371                                 mbs.param[5] = nw;
 372                                 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
 373                                 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
 374                                 mbs.param[8] = la >> 16;
 375                                 isp_prt(isp, ISP_LOGDEBUG0, "LOAD RISC RAM %u words at load address 0x%x", nw, la);
 376                                 isp_mboxcmd(isp, &mbs);
 377                                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 378                                         isp_prt(isp, ISP_LOGERR, "F/W download failed");
 379                                         return;
 380                                 }
 381                                 la += nw;
 382                                 wi += nw;
 383                                 wl -= nw;
 384                         }
 385
 386                         if (ptr[1] == 0) {
 387                                 break;
 388                         }
 389                         ptr += ptr[3];
 390                 }
 391                 loaded_fw = 1;
 392         } else if (IS_26XX(isp)) {
 393                 isp_prt(isp, ISP_LOGDEBUG1, "loading firmware from flash");
 394                 MBSINIT(&mbs, MBOX_LOAD_FLASH_FIRMWARE, MBLOGALL, 5000000);
 395                 mbs.ibitm = 0x01;
 396                 mbs.obitm = 0x07;
 397                 isp_mboxcmd(isp, &mbs);
 398                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 399                         isp_prt(isp, ISP_LOGERR, "Flash F/W load failed");
 400                         return;
 401                 }
 402         } else {
 403                 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
 404         }
 405
 406         /*
 407          * If we loaded firmware, verify its checksum
 408          */
 409         if (loaded_fw) {
 410                 MBSINIT(&mbs, MBOX_VERIFY_CHECKSUM, MBLOGNONE, 0);
 411                 mbs.param[1] = code_org >> 16;
 412                 mbs.param[2] = code_org;
 413                 isp_mboxcmd(isp, &mbs);
 414                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 415                         isp_prt(isp, ISP_LOGERR, dcrc);
 416                         return;
 417                 }
 418         }
 419
 420         /*
 421          * Now start it rolling.
 422          *
 423          * If we didn't actually download f/w,
 424          * we still need to (re)start it.
 425          */
 426         MBSINIT(&mbs, MBOX_EXEC_FIRMWARE, MBLOGALL, 5000000);
 427         mbs.param[1] = code_org >> 16;
 428         mbs.param[2] = code_org;
 429         if (!IS_26XX(isp))
 430                 mbs.param[3] = loaded_fw ? 0 : 1;
 431         isp_mboxcmd(isp, &mbs);
 432         if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
 433                 return;
 434
 435         /*
 436          * Ask the chip for the current firmware version.
 437          * This should prove that the new firmware is working.
 438          */
 439         MBSINIT(&mbs, MBOX_ABOUT_FIRMWARE, MBLOGALL, 5000000);
 440         isp_mboxcmd(isp, &mbs);
 441         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 442                 return;
 443         }
 444
 445         isp->isp_fwrev[0] = mbs.param[1];
 446         isp->isp_fwrev[1] = mbs.param[2];
 447         isp->isp_fwrev[2] = mbs.param[3];
 448         isp->isp_fwattr = mbs.param[6];
 449         isp->isp_fwattr |= ((uint64_t) mbs.param[15]) << 16;
 450         if (isp->isp_fwattr & ISP2400_FW_ATTR_EXTNDED) {
 451                 isp->isp_fwattr |=
 452                     (((uint64_t) mbs.param[16]) << 32) |
 453                     (((uint64_t) mbs.param[17]) << 48);
 454         }
 455
 456         isp_prt(isp, ISP_LOGCONFIG, "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
 457             btype, isp->isp_revision, dodnld? "loaded" : "resident", isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
 458
 459         fwt = isp->isp_fwattr;
 460         buf = FCPARAM(isp, 0)->isp_scanscratch;
 461         ISP_SNPRINTF(buf, ISP_FC_SCRLEN, "Attributes:");
 462         if (fwt & ISP2400_FW_ATTR_CLASS2) {
 463                 fwt ^=ISP2400_FW_ATTR_CLASS2;
 464                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Class2", buf);
 465         }
 466         if (fwt & ISP2400_FW_ATTR_IP) {
 467                 fwt ^=ISP2400_FW_ATTR_IP;
 468                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s IP", buf);
 469         }
 470         if (fwt & ISP2400_FW_ATTR_MULTIID) {
 471                 fwt ^=ISP2400_FW_ATTR_MULTIID;
 472                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MultiID", buf);
 473         }
 474         if (fwt & ISP2400_FW_ATTR_SB2) {
 475                 fwt ^=ISP2400_FW_ATTR_SB2;
 476                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SB2", buf);
 477         }
 478         if (fwt & ISP2400_FW_ATTR_T10CRC) {
 479                 fwt ^=ISP2400_FW_ATTR_T10CRC;
 480                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s T10CRC", buf);
 481         }
 482         if (fwt & ISP2400_FW_ATTR_VI) {
 483                 fwt ^=ISP2400_FW_ATTR_VI;
 484                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI", buf);
 485         }
 486         if (fwt & ISP2400_FW_ATTR_MQ) {
 487                 fwt ^=ISP2400_FW_ATTR_MQ;
 488                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MQ", buf);
 489         }
 490         if (fwt & ISP2400_FW_ATTR_MSIX) {
 491                 fwt ^=ISP2400_FW_ATTR_MSIX;
 492                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MSIX", buf);
 493         }
 494         if (fwt & ISP2400_FW_ATTR_FCOE) {
 495                 fwt ^=ISP2400_FW_ATTR_FCOE;
 496                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s FCOE", buf);
 497         }
 498         if (fwt & ISP2400_FW_ATTR_VP0) {
 499                 fwt ^= ISP2400_FW_ATTR_VP0;
 500                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VP0_Decoupling", buf);
 501         }
 502         if (fwt & ISP2400_FW_ATTR_EXPFW) {
 503                 fwt ^= ISP2400_FW_ATTR_EXPFW;
 504                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (Experimental)", buf);
 505         }
 506         if (fwt & ISP2400_FW_ATTR_HOTFW) {
 507                 fwt ^= ISP2400_FW_ATTR_HOTFW;
 508                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s HotFW", buf);
 509         }
 510         fwt &= ~ISP2400_FW_ATTR_EXTNDED;
 511         if (fwt & ISP2400_FW_ATTR_EXTVP) {
 512                 fwt ^= ISP2400_FW_ATTR_EXTVP;
 513                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ExtVP", buf);
 514         }
 515         if (fwt & ISP2400_FW_ATTR_VN2VN) {
 516                 fwt ^= ISP2400_FW_ATTR_VN2VN;
 517                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VN2VN", buf);
 518         }
 519         if (fwt & ISP2400_FW_ATTR_EXMOFF) {
 520                 fwt ^= ISP2400_FW_ATTR_EXMOFF;
 521                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s EXMOFF", buf);
 522         }
 523         if (fwt & ISP2400_FW_ATTR_NPMOFF) {
 524                 fwt ^= ISP2400_FW_ATTR_NPMOFF;
 525                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s NPMOFF", buf);
 526         }
 527         if (fwt & ISP2400_FW_ATTR_DIFCHOP) {
 528                 fwt ^= ISP2400_FW_ATTR_DIFCHOP;
 529                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s DIFCHOP", buf);
 530         }
 531         if (fwt & ISP2400_FW_ATTR_SRIOV) {
 532                 fwt ^= ISP2400_FW_ATTR_SRIOV;
 533                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SRIOV", buf);
 534         }
 535         if (fwt & ISP2400_FW_ATTR_ASICTMP) {
 536                 fwt ^= ISP2400_FW_ATTR_ASICTMP;
 537                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ASICTMP", buf);
 538         }
 539         if (fwt & ISP2400_FW_ATTR_ATIOMQ) {
 540                 fwt ^= ISP2400_FW_ATTR_ATIOMQ;
 541                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ATIOMQ", buf);
 542         }
 543         if (fwt) {
 544                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (unknown 0x%08x%08x)", buf,
 545                     (uint32_t) (fwt >> 32), (uint32_t) fwt);
 546         }
 547         isp_prt(isp, ISP_LOGCONFIG, "%s", buf);
 548
 549         /*
 550          * For the maximum number of commands take free exchange control block
 551          * buffer count reported by firmware, limiting it to the maximum of our
 552          * hardcoded handle format (16K now) minus some management reserve.
 553          */
 554         MBSINIT(&mbs, MBOX_GET_RESOURCE_COUNT, MBLOGALL, 0);
 555         isp_mboxcmd(isp, &mbs);
 556         if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
 557                 return;
 558         isp->isp_maxcmds = MIN(mbs.param[3], ISP_HANDLE_MAX - ISP_HANDLE_RESERVE);
 559         isp_prt(isp, ISP_LOGCONFIG, "%d max I/O command limit set", isp->isp_maxcmds);
 560
 561         /*
 562          * If we don't have Multi-ID f/w loaded, we need to restrict channels to one.
 563          * Only make this check for non-SCSI cards (I'm not sure firmware attributes
 564          * work for them).
 565          */
 566         if (isp->isp_nchan > 1) {
 567                 if (!ISP_CAP_MULTI_ID(isp)) {
 568                         isp_prt(isp, ISP_LOGWARN, "non-MULTIID f/w loaded, "
 569                             "only can enable 1 of %d channels", isp->isp_nchan);
 570                         isp->isp_nchan = 1;
 571                 } else if (!ISP_CAP_VP0(isp)) {
 572                         isp_prt(isp, ISP_LOGWARN, "We can not use MULTIID "
 573                             "feature properly without VP0_Decoupling");
 574                         isp->isp_nchan = 1;
 575                 }
 576         }
 577
 578         /*
 579          * Final DMA setup after we got isp_maxcmds.
 580          */
 581         if (ISP_MBOXDMASETUP(isp) != 0) {
 582                 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
 583                 return;
 584         }
 585
 586         /*
 587          * Setup interrupts.
 588          */
 589         if (ISP_IRQSETUP(isp) != 0) {
 590                 isp_prt(isp, ISP_LOGERR, "Cannot setup IRQ");
 591                 return;
 592         }
 593         ISP_ENABLE_INTS(isp);
 594
 595         for (i = 0; i < isp->isp_nchan; i++)
 596                 isp_change_fw_state(isp, i, FW_CONFIG_WAIT);
 597
 598         isp->isp_state = ISP_RESETSTATE;
 599
 600         /*
 601          * We get some default values established. As a side
 602          * effect, NVRAM is read here (unless overriden by
 603          * a configuration flag).
 604          */
 605         if (do_load_defaults) {
 606                 for (i = 0; i < isp->isp_nchan; i++)
 607                         isp_setdfltfcparm(isp, i);
 608         }
 609 }
 610
 611 /*
 612  * Clean firmware shutdown.
 613  */
 614 static int
 615 isp_stop(ispsoftc_t *isp)
 616 {
 617         mbreg_t mbs;
 618
 619         isp->isp_state = ISP_NILSTATE;
 620         MBSINIT(&mbs, MBOX_STOP_FIRMWARE, MBLOGALL, 500000);
 621         mbs.param[1] = 0;
 622         mbs.param[2] = 0;
 623         mbs.param[3] = 0;
 624         mbs.param[4] = 0;
 625         mbs.param[5] = 0;
 626         mbs.param[6] = 0;
 627         mbs.param[7] = 0;
 628         mbs.param[8] = 0;
 629         isp_mboxcmd(isp, &mbs);
 630         return (mbs.param[0] == MBOX_COMMAND_COMPLETE ? 0 : mbs.param[0]);
 631 }
 632
 633 /*
 634  * Hardware shutdown.
 635  */
 636 void
 637 isp_shutdown(ispsoftc_t *isp)
 638 {
 639
 640         if (isp->isp_state >= ISP_RESETSTATE)
 641                 isp_stop(isp);
 642         ISP_DISABLE_INTS(isp);
 643         ISP_WRITE(isp, BIU2400_ICR, 0);
 644         ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
 645 }
 646
 647 /*
 648  * Initialize Parameters of Hardware to a known state.
 649  *
 650  * Locks are held before coming here.
 651  */
 652 void
 653 isp_init(ispsoftc_t *isp)
 654 {
 655         fcparam *fcp;
 656         isp_icb_2400_t local, *icbp = &local;
 657         mbreg_t mbs;
 658         int chan;
 659         int ownloopid = 0;
 660
 661         /*
 662          * Check to see whether all channels have *some* kind of role
 663          */
 664         for (chan = 0; chan < isp->isp_nchan; chan++) {
 665                 fcp = FCPARAM(isp, chan);
 666                 if (fcp->role != ISP_ROLE_NONE) {
 667                         break;
 668                 }
 669         }
 670         if (chan == isp->isp_nchan) {
 671                 isp_prt(isp, ISP_LOG_WARN1, "all %d channels with role 'none'", chan);
 672                 return;
 673         }
 674
 675         isp->isp_state = ISP_INITSTATE;
 676
 677         /*
 678          * Start with channel 0.
 679          */
 680         fcp = FCPARAM(isp, 0);
 681
 682         /*
 683          * Turn on LIP F8 async event (1)
 684          */
 685         MBSINIT(&mbs, MBOX_SET_FIRMWARE_OPTIONS, MBLOGALL, 0);
 686         mbs.param[1] = 1;
 687         isp_mboxcmd(isp, &mbs);
 688         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 689                 return;
 690         }
 691
 692         ISP_MEMZERO(icbp, sizeof (*icbp));
 693         icbp->icb_fwoptions1 = fcp->isp_fwoptions;
 694         icbp->icb_fwoptions2 = fcp->isp_xfwoptions;
 695         icbp->icb_fwoptions3 = fcp->isp_zfwoptions;
 696         if (isp->isp_nchan > 1 && ISP_CAP_VP0(isp)) {
 697                 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_INI_DISABLE;
 698                 icbp->icb_fwoptions1 |= ICB2400_OPT1_TGT_ENABLE;
 699         } else {
 700                 if (fcp->role & ISP_ROLE_TARGET)
 701                         icbp->icb_fwoptions1 |= ICB2400_OPT1_TGT_ENABLE;
 702                 else
 703                         icbp->icb_fwoptions1 &= ~ICB2400_OPT1_TGT_ENABLE;
 704                 if (fcp->role & ISP_ROLE_INITIATOR)
 705                         icbp->icb_fwoptions1 &= ~ICB2400_OPT1_INI_DISABLE;
 706                 else
 707                         icbp->icb_fwoptions1 |= ICB2400_OPT1_INI_DISABLE;
 708         }
 709
 710         icbp->icb_version = ICB_VERSION1;
 711         icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
 712         if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
 713                 isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
 714                 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
 715         }
 716
 717         if (!IS_26XX(isp))
 718                 icbp->icb_execthrottle = 0xffff;
 719
 720 #ifdef  ISP_TARGET_MODE
 721         /*
 722          * Set target exchange count. Take half if we are supporting both roles.
 723          */
 724         if (icbp->icb_fwoptions1 & ICB2400_OPT1_TGT_ENABLE) {
 725                 if ((icbp->icb_fwoptions1 & ICB2400_OPT1_INI_DISABLE) == 0)
 726                         icbp->icb_xchgcnt = MIN(isp->isp_maxcmds / 2, ATPDPSIZE);
 727                 else
 728                         icbp->icb_xchgcnt = isp->isp_maxcmds;
 729         }
 730 #endif
 731
 732         ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
 733         icbp->icb_hardaddr = fcp->isp_loopid;
 734         if (icbp->icb_hardaddr >= LOCAL_LOOP_LIM) {
 735                 icbp->icb_hardaddr = 0;
 736                 ownloopid = 0;
 737         }
 738
 739         if (ownloopid)
 740                 icbp->icb_fwoptions1 |= ICB2400_OPT1_HARD_ADDRESS;
 741
 742         if (isp->isp_confopts & ISP_CFG_NOFCTAPE) {
 743                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_FCTAPE;
 744         }
 745         if (isp->isp_confopts & ISP_CFG_FCTAPE) {
 746                 icbp->icb_fwoptions2 |= ICB2400_OPT2_FCTAPE;
 747         }
 748
 749         for (chan = 0; chan < isp->isp_nchan; chan++) {
 750                 if (icbp->icb_fwoptions2 & ICB2400_OPT2_FCTAPE)
 751                         FCPARAM(isp, chan)->fctape_enabled = 1;
 752                 else
 753                         FCPARAM(isp, chan)->fctape_enabled = 0;
 754         }
 755
 756         switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
 757         case ISP_CFG_LPORT_ONLY:
 758                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
 759                 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_ONLY;
 760                 break;
 761         case ISP_CFG_NPORT_ONLY:
 762                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
 763                 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_ONLY;
 764                 break;
 765         case ISP_CFG_NPORT:
 766                 /* ISP_CFG_PTP_2_LOOP not available in 24XX/25XX */
 767         case ISP_CFG_LPORT:
 768                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
 769                 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
 770                 break;
 771         default:
 772                 /* Let NVRAM settings define it if they are sane */
 773                 switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TOPO_MASK) {
 774                 case ICB2400_OPT2_LOOP_ONLY:
 775                 case ICB2400_OPT2_PTP_ONLY:
 776                 case ICB2400_OPT2_LOOP_2_PTP:
 777                         break;
 778                 default:
 779                         icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
 780                         icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
 781                 }
 782                 break;
 783         }
 784
 785         switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK) {
 786         case ICB2400_OPT2_ZIO:
 787         case ICB2400_OPT2_ZIO1:
 788                 icbp->icb_idelaytimer = 0;
 789                 break;
 790         case 0:
 791                 break;
 792         default:
 793                 isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field", icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
 794                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TIMER_MASK;
 795                 break;
 796         }
 797
 798         if (IS_26XX(isp)) {
 799                 /* Use handshake to reduce global lock congestion. */
 800                 icbp->icb_fwoptions2 |= ICB2400_OPT2_ENA_IHR;
 801                 icbp->icb_fwoptions2 |= ICB2400_OPT2_ENA_IHA;
 802         }
 803
 804         if ((icbp->icb_fwoptions3 & ICB2400_OPT3_RSPSZ_MASK) == 0) {
 805                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RSPSZ_24;
 806         }
 807         if (isp->isp_confopts & ISP_CFG_1GB) {
 808                 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
 809                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_1GB;
 810         } else if (isp->isp_confopts & ISP_CFG_2GB) {
 811                 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
 812                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_2GB;
 813         } else if (isp->isp_confopts & ISP_CFG_4GB) {
 814                 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
 815                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_4GB;
 816         } else if (isp->isp_confopts & ISP_CFG_8GB) {
 817                 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
 818                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_8GB;
 819         } else if (isp->isp_confopts & ISP_CFG_16GB) {
 820                 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
 821                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_16GB;
 822         } else if (isp->isp_confopts & ISP_CFG_32GB) {
 823                 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
 824                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_32GB;
 825         } else {
 826                 switch (icbp->icb_fwoptions3 & ICB2400_OPT3_RATE_MASK) {
 827                 case ICB2400_OPT3_RATE_4GB:
 828                 case ICB2400_OPT3_RATE_8GB:
 829                 case ICB2400_OPT3_RATE_16GB:
 830                 case ICB2400_OPT3_RATE_32GB:
 831                 case ICB2400_OPT3_RATE_AUTO:
 832                         break;
 833                 case ICB2400_OPT3_RATE_2GB:
 834                         if (isp->isp_type <= ISP_HA_FC_2500)
 835                                 break;
 836                         /*FALLTHROUGH*/
 837                 case ICB2400_OPT3_RATE_1GB:
 838                         if (isp->isp_type <= ISP_HA_FC_2400)
 839                                 break;
 840                         /*FALLTHROUGH*/
 841                 default:
 842                         icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
 843                         icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_AUTO;
 844                         break;
 845                 }
 846         }
 847         if (ownloopid == 0) {
 848                 icbp->icb_fwoptions3 |= ICB2400_OPT3_SOFTID;
 849         }
 850         icbp->icb_logintime = ICB_LOGIN_TOV;
 851
 852         if (fcp->isp_wwnn && fcp->isp_wwpn) {
 853                 icbp->icb_fwoptions1 |= ICB2400_OPT1_BOTH_WWNS;
 854                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
 855                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwnn);
 856                 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)),
 857                     ((uint32_t) (fcp->isp_wwpn >> 32)), ((uint32_t) (fcp->isp_wwpn)));
 858         } else if (fcp->isp_wwpn) {
 859                 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_BOTH_WWNS;
 860                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
 861                 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)));
 862         } else {
 863                 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
 864                 return;
 865         }
 866         icbp->icb_rspnsin = isp->isp_resodx;
 867         icbp->icb_rqstout = isp->isp_reqidx;
 868         icbp->icb_retry_count = fcp->isp_retry_count;
 869
 870         icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
 871         if (icbp->icb_rqstqlen < 8) {
 872                 isp_prt(isp, ISP_LOGERR, "bad request queue length %d", icbp->icb_rqstqlen);
 873                 return;
 874         }
 875         icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
 876         if (icbp->icb_rsltqlen < 8) {
 877                 isp_prt(isp, ISP_LOGERR, "bad result queue length %d",
 878                     icbp->icb_rsltqlen);
 879                 return;
 880         }
 881         icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
 882         icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
 883         icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
 884         icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
 885
 886         icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
 887         icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
 888         icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
 889         icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
 890
 891 #ifdef  ISP_TARGET_MODE
 892         /* unconditionally set up the ATIO queue if we support target mode */
 893         icbp->icb_atio_in = isp->isp_atioodx;
 894         icbp->icb_atioqlen = ATIO_QUEUE_LEN(isp);
 895         if (icbp->icb_atioqlen < 8) {
 896                 isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d", icbp->icb_atioqlen);
 897                 return;
 898         }
 899         icbp->icb_atioqaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_atioq_dma);
 900         icbp->icb_atioqaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_atioq_dma);
 901         icbp->icb_atioqaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_atioq_dma);
 902         icbp->icb_atioqaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_atioq_dma);
 903         isp_prt(isp, ISP_LOGDEBUG0, "isp_init: atioq %04x%04x%04x%04x", DMA_WD3(isp->isp_atioq_dma), DMA_WD2(isp->isp_atioq_dma),
 904             DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
 905 #endif
 906
 907         if (ISP_CAP_MSIX(isp) && isp->isp_nirq >= 2) {
 908                 icbp->icb_msixresp = 1;
 909                 if (IS_26XX(isp) && isp->isp_nirq >= 3)
 910                         icbp->icb_msixatio = 2;
 911         }
 912
 913         isp_prt(isp, ISP_LOGDEBUG0, "isp_init: fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x", icbp->icb_fwoptions1, icbp->icb_fwoptions2, icbp->icb_fwoptions3);
 914
 915         isp_prt(isp, ISP_LOGDEBUG0, "isp_init: rqst %04x%04x%04x%04x rsp %04x%04x%04x%04x", DMA_WD3(isp->isp_rquest_dma), DMA_WD2(isp->isp_rquest_dma),
 916             DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma), DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
 917             DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
 918
 919         if (FC_SCRATCH_ACQUIRE(isp, 0)) {
 920                 isp_prt(isp, ISP_LOGERR, sacq);
 921                 return;
 922         }
 923         ISP_MEMZERO(fcp->isp_scratch, ISP_FC_SCRLEN);
 924         isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
 925         if (isp->isp_dblev & ISP_LOGDEBUG1) {
 926                 isp_print_bytes(isp, "isp_init",
 927                     sizeof (*icbp), fcp->isp_scratch);
 928         }
 929
 930         /*
 931          * Now fill in information about any additional channels
 932          */
 933         if (isp->isp_nchan > 1) {
 934                 isp_icb_2400_vpinfo_t vpinfo, *vdst;
 935                 vp_port_info_t pi, *pdst;
 936                 size_t amt = 0;
 937                 uint8_t *off;
 938
 939                 vpinfo.vp_global_options = ICB2400_VPGOPT_GEN_RIDA;
 940                 if (ISP_CAP_VP0(isp)) {
 941                         vpinfo.vp_global_options |= ICB2400_VPGOPT_VP0_DECOUPLE;
 942                         vpinfo.vp_count = isp->isp_nchan;
 943                         chan = 0;
 944                 } else {
 945                         vpinfo.vp_count = isp->isp_nchan - 1;
 946                         chan = 1;
 947                 }
 948                 off = fcp->isp_scratch;
 949                 off += ICB2400_VPINFO_OFF;
 950                 vdst = (isp_icb_2400_vpinfo_t *) off;
 951                 isp_put_icb_2400_vpinfo(isp, &vpinfo, vdst);
 952                 amt = ICB2400_VPINFO_OFF + sizeof (isp_icb_2400_vpinfo_t);
 953                 for (; chan < isp->isp_nchan; chan++) {
 954                         fcparam *fcp2;
 955
 956                         ISP_MEMZERO(&pi, sizeof (pi));
 957                         fcp2 = FCPARAM(isp, chan);
 958                         if (fcp2->role != ISP_ROLE_NONE) {
 959                                 pi.vp_port_options = ICB2400_VPOPT_ENABLED |
 960                                     ICB2400_VPOPT_ENA_SNSLOGIN;
 961                                 if (fcp2->role & ISP_ROLE_INITIATOR)
 962                                         pi.vp_port_options |= ICB2400_VPOPT_INI_ENABLE;
 963                                 if ((fcp2->role & ISP_ROLE_TARGET) == 0)
 964                                         pi.vp_port_options |= ICB2400_VPOPT_TGT_DISABLE;
 965                                 if (fcp2->isp_loopid < LOCAL_LOOP_LIM) {
 966                                         pi.vp_port_loopid = fcp2->isp_loopid;
 967                                         if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
 968                                                 pi.vp_port_options |= ICB2400_VPOPT_HARD_ADDRESS;
 969                                 }
 970
 971                         }
 972                         MAKE_NODE_NAME_FROM_WWN(pi.vp_port_portname, fcp2->isp_wwpn);
 973                         MAKE_NODE_NAME_FROM_WWN(pi.vp_port_nodename, fcp2->isp_wwnn);
 974                         off = fcp->isp_scratch;
 975                         if (ISP_CAP_VP0(isp))
 976                                 off += ICB2400_VPINFO_PORT_OFF(chan);
 977                         else
 978                                 off += ICB2400_VPINFO_PORT_OFF(chan - 1);
 979                         pdst = (vp_port_info_t *) off;
 980                         isp_put_vp_port_info(isp, &pi, pdst);
 981                         amt += ICB2400_VPOPT_WRITE_SIZE;
 982                 }
 983                 if (isp->isp_dblev & ISP_LOGDEBUG1) {
 984                         isp_print_bytes(isp, "isp_init",
 985                             amt - ICB2400_VPINFO_OFF,
 986                             (char *)fcp->isp_scratch + ICB2400_VPINFO_OFF);
 987                 }
 988         }
 989
 990         /*
 991          * Init the firmware
 992          */
 993         MBSINIT(&mbs, 0, MBLOGALL, 30000000);
 994         if (isp->isp_nchan > 1) {
 995                 mbs.param[0] = MBOX_INIT_FIRMWARE_MULTI_ID;
 996         } else {
 997                 mbs.param[0] = MBOX_INIT_FIRMWARE;
 998         }
 999         mbs.param[1] = 0;
1000         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1001         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1002         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1003         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1004         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));
1005         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
1006         isp_mboxcmd(isp, &mbs);
1007         FC_SCRATCH_RELEASE(isp, 0);
1008
1009         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1010                 return;
1011         }
1012
1013         /*
1014          * Whatever happens, we're now committed to being here.
1015          */
1016         isp->isp_state = ISP_RUNSTATE;
1017 }
1018
1019 static int
1020 isp_fc_enable_vp(ispsoftc_t *isp, int chan)
1021 {
1022         fcparam *fcp = FCPARAM(isp, chan);
1023         vp_modify_t vp;
1024         int retval;
1025
1026         /* Build a VP MODIFY command in memory */
1027         ISP_MEMZERO(&vp, sizeof(vp));
1028         vp.vp_mod_hdr.rqs_entry_type = RQSTYPE_VP_MODIFY;
1029         vp.vp_mod_hdr.rqs_entry_count = 1;
1030         vp.vp_mod_cnt = 1;
1031         vp.vp_mod_idx0 = chan;
1032         vp.vp_mod_cmd = VP_MODIFY_ENA;
1033         vp.vp_mod_ports[0].options = ICB2400_VPOPT_ENABLED |
1034             ICB2400_VPOPT_ENA_SNSLOGIN;
1035         if (fcp->role & ISP_ROLE_INITIATOR)
1036                 vp.vp_mod_ports[0].options |= ICB2400_VPOPT_INI_ENABLE;
1037         if ((fcp->role & ISP_ROLE_TARGET) == 0)
1038                 vp.vp_mod_ports[0].options |= ICB2400_VPOPT_TGT_DISABLE;
1039         if (fcp->isp_loopid < LOCAL_LOOP_LIM) {
1040                 vp.vp_mod_ports[0].loopid = fcp->isp_loopid;
1041                 if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
1042                         vp.vp_mod_ports[0].options |= ICB2400_VPOPT_HARD_ADDRESS;
1043         }
1044         MAKE_NODE_NAME_FROM_WWN(vp.vp_mod_ports[0].wwpn, fcp->isp_wwpn);
1045         MAKE_NODE_NAME_FROM_WWN(vp.vp_mod_ports[0].wwnn, fcp->isp_wwnn);
1046
1047         retval = isp_exec_entry_queue(isp, &vp, &vp, 5);
1048         if (retval != 0) {
1049                 isp_prt(isp, ISP_LOGERR, "%s: VP_MODIFY of chan %d error %d",
1050                     __func__, chan, retval);
1051                 return (retval);
1052         }
1053
1054         if (vp.vp_mod_hdr.rqs_flags != 0 || vp.vp_mod_status != VP_STS_OK) {
1055                 isp_prt(isp, ISP_LOGERR,
1056                     "%s: VP_MODIFY of Chan %d failed with flags %x status %d",
1057                     __func__, chan, vp.vp_mod_hdr.rqs_flags, vp.vp_mod_status);
1058                 return (EIO);
1059         }
1060         return (0);
1061 }
1062
1063 static int
1064 isp_fc_disable_vp(ispsoftc_t *isp, int chan)
1065 {
1066         vp_ctrl_info_t vp;
1067         int retval;
1068
1069         /* Build a VP CTRL command in memory */
1070         ISP_MEMZERO(&vp, sizeof(vp));
1071         vp.vp_ctrl_hdr.rqs_entry_type = RQSTYPE_VP_CTRL;
1072         vp.vp_ctrl_hdr.rqs_entry_count = 1;
1073         if (ISP_CAP_VP0(isp)) {
1074                 vp.vp_ctrl_status = 1;
1075         } else {
1076                 vp.vp_ctrl_status = 0;
1077                 chan--; /* VP0 can not be controlled in this case. */
1078         }
1079         vp.vp_ctrl_command = VP_CTRL_CMD_DISABLE_VP_LOGO_ALL;
1080         vp.vp_ctrl_vp_count = 1;
1081         vp.vp_ctrl_idmap[chan / 16] |= (1 << chan % 16);
1082
1083         retval = isp_exec_entry_queue(isp, &vp, &vp, 5);
1084         if (retval != 0) {
1085                 isp_prt(isp, ISP_LOGERR, "%s: VP_CTRL of chan %d error %d",
1086                     __func__, chan, retval);
1087                 return (retval);
1088         }
1089
1090         if (vp.vp_ctrl_hdr.rqs_flags != 0 || vp.vp_ctrl_status != 0) {
1091                 isp_prt(isp, ISP_LOGERR,
1092                     "%s: VP_CTRL of Chan %d failed with flags %x status %d %d",
1093                     __func__, chan, vp.vp_ctrl_hdr.rqs_flags,
1094                     vp.vp_ctrl_status, vp.vp_ctrl_index_fail);
1095                 return (EIO);
1096         }
1097         return (0);
1098 }
1099
1100 static int
1101 isp_fc_change_role(ispsoftc_t *isp, int chan, int new_role)
1102 {
1103         fcparam *fcp = FCPARAM(isp, chan);
1104         int i, was, res = 0;
1105
1106         if (chan >= isp->isp_nchan) {
1107                 isp_prt(isp, ISP_LOGWARN, "%s: bad channel %d", __func__, chan);
1108                 return (ENXIO);
1109         }
1110         if (fcp->role == new_role)
1111                 return (0);
1112         for (was = 0, i = 0; i < isp->isp_nchan; i++) {
1113                 if (FCPARAM(isp, i)->role != ISP_ROLE_NONE)
1114                         was++;
1115         }
1116         if (was == 0 || (was == 1 && fcp->role != ISP_ROLE_NONE)) {
1117                 fcp->role = new_role;
1118                 return (isp_reinit(isp, 0));
1119         }
1120         if (fcp->role != ISP_ROLE_NONE) {
1121                 res = isp_fc_disable_vp(isp, chan);
1122                 isp_clear_portdb(isp, chan);
1123         }
1124         fcp->role = new_role;
1125         if (fcp->role != ISP_ROLE_NONE)
1126                 res = isp_fc_enable_vp(isp, chan);
1127         return (res);
1128 }
1129
1130 static void
1131 isp_clear_portdb(ispsoftc_t *isp, int chan)
1132 {
1133         fcparam *fcp = FCPARAM(isp, chan);
1134         fcportdb_t *lp;
1135         int i;
1136
1137         for (i = 0; i < MAX_FC_TARG; i++) {
1138                 lp = &fcp->portdb[i];
1139                 switch (lp->state) {
1140                 case FC_PORTDB_STATE_DEAD:
1141                 case FC_PORTDB_STATE_CHANGED:
1142                 case FC_PORTDB_STATE_VALID:
1143                         lp->state = FC_PORTDB_STATE_NIL;
1144                         isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
1145                         break;
1146                 case FC_PORTDB_STATE_NIL:
1147                 case FC_PORTDB_STATE_NEW:
1148                         lp->state = FC_PORTDB_STATE_NIL;
1149                         break;
1150                 case FC_PORTDB_STATE_ZOMBIE:
1151                         break;
1152                 default:
1153                         panic("Don't know how to clear state %d\n", lp->state);
1154                 }
1155         }
1156 }
1157
1158 static void
1159 isp_mark_portdb(ispsoftc_t *isp, int chan)
1160 {
1161         fcparam *fcp = FCPARAM(isp, chan);
1162         fcportdb_t *lp;
1163         int i;
1164
1165         for (i = 0; i < MAX_FC_TARG; i++) {
1166                 lp = &fcp->portdb[i];
1167                 if (lp->state == FC_PORTDB_STATE_NIL)
1168                         continue;
1169                 if (lp->portid >= DOMAIN_CONTROLLER_BASE &&
1170                     lp->portid <= DOMAIN_CONTROLLER_END)
1171                         continue;
1172                 fcp->portdb[i].probational = 1;
1173         }
1174 }
1175
1176 /*
1177  * Perform an IOCB PLOGI or LOGO via EXECUTE IOCB A64 for 24XX cards
1178  * or via FABRIC LOGIN/FABRIC LOGOUT for other cards.
1179  */
1180 static int
1181 isp_plogx(ispsoftc_t *isp, int chan, uint16_t handle, uint32_t portid, int flags)
1182 {
1183         isp_plogx_t pl;
1184         uint32_t sst, parm1;
1185         int retval, lev;
1186         const char *msg;
1187         char buf[64];
1188
1189         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d PLOGX %s PortID 0x%06x nphdl 0x%x",
1190             chan, (flags & PLOGX_FLG_CMD_MASK) == PLOGX_FLG_CMD_PLOGI ?
1191             "Login":"Logout", portid, handle);
1192
1193         ISP_MEMZERO(&pl, sizeof(pl));
1194         pl.plogx_header.rqs_entry_count = 1;
1195         pl.plogx_header.rqs_entry_type = RQSTYPE_LOGIN;
1196         pl.plogx_nphdl = handle;
1197         pl.plogx_vphdl = chan;
1198         pl.plogx_portlo = portid;
1199         pl.plogx_rspsz_porthi = (portid >> 16) & 0xff;
1200         pl.plogx_flags = flags;
1201
1202         retval = isp_exec_entry_queue(isp, &pl, &pl, 3 * ICB_LOGIN_TOV);
1203         if (retval != 0) {
1204                 isp_prt(isp, ISP_LOGERR, "%s: PLOGX of chan %d error %d",
1205                     __func__, chan, retval);
1206                 return (retval);
1207         }
1208
1209         if (pl.plogx_status == PLOGX_STATUS_OK) {
1210                 return (0);
1211         } else if (pl.plogx_status != PLOGX_STATUS_IOCBERR) {
1212                 isp_prt(isp, ISP_LOGWARN,
1213                     "status 0x%x on port login IOCB channel %d",
1214                     pl.plogx_status, chan);
1215                 return (-1);
1216         }
1217
1218         sst = pl.plogx_ioparm[0].lo16 | (pl.plogx_ioparm[0].hi16 << 16);
1219         parm1 = pl.plogx_ioparm[1].lo16 | (pl.plogx_ioparm[1].hi16 << 16);
1220
1221         retval = -1;
1222         lev = ISP_LOGERR;
1223         msg = NULL;
1224
1225         switch (sst) {
1226         case PLOGX_IOCBERR_NOLINK:
1227                 msg = "no link";
1228                 break;
1229         case PLOGX_IOCBERR_NOIOCB:
1230                 msg = "no IOCB buffer";
1231                 break;
1232         case PLOGX_IOCBERR_NOXGHG:
1233                 msg = "no Exchange Control Block";
1234                 break;
1235         case PLOGX_IOCBERR_FAILED:
1236                 ISP_SNPRINTF(buf, sizeof (buf), "reason 0x%x (last LOGIN state 0x%x)", parm1 & 0xff, (parm1 >> 8) & 0xff);
1237                 msg = buf;
1238                 break;
1239         case PLOGX_IOCBERR_NOFABRIC:
1240                 msg = "no fabric";
1241                 break;
1242         case PLOGX_IOCBERR_NOTREADY:
1243                 msg = "firmware not ready";
1244                 break;
1245         case PLOGX_IOCBERR_NOLOGIN:
1246                 ISP_SNPRINTF(buf, sizeof (buf), "not logged in (last state 0x%x)", parm1);
1247                 msg = buf;
1248                 retval = MBOX_NOT_LOGGED_IN;
1249                 break;
1250         case PLOGX_IOCBERR_REJECT:
1251                 ISP_SNPRINTF(buf, sizeof (buf), "LS_RJT = 0x%x", parm1);
1252                 msg = buf;
1253                 break;
1254         case PLOGX_IOCBERR_NOPCB:
1255                 msg = "no PCB allocated";
1256                 break;
1257         case PLOGX_IOCBERR_EINVAL:
1258                 ISP_SNPRINTF(buf, sizeof (buf), "invalid parameter at offset 0x%x", parm1);
1259                 msg = buf;
1260                 break;
1261         case PLOGX_IOCBERR_PORTUSED:
1262                 lev = ISP_LOG_SANCFG|ISP_LOG_WARN1;
1263                 ISP_SNPRINTF(buf, sizeof (buf), "already logged in with N-Port handle 0x%x", parm1);
1264                 msg = buf;
1265                 retval = MBOX_PORT_ID_USED | (parm1 << 16);
1266                 break;
1267         case PLOGX_IOCBERR_HNDLUSED:
1268                 lev = ISP_LOG_SANCFG|ISP_LOG_WARN1;
1269                 ISP_SNPRINTF(buf, sizeof (buf), "handle already used for PortID 0x%06x", parm1);
1270                 msg = buf;
1271                 retval = MBOX_LOOP_ID_USED;
1272                 break;
1273         case PLOGX_IOCBERR_NOHANDLE:
1274                 msg = "no handle allocated";
1275                 break;
1276         case PLOGX_IOCBERR_NOFLOGI:
1277                 msg = "no FLOGI_ACC";
1278                 break;
1279         default:
1280                 ISP_SNPRINTF(buf, sizeof (buf), "status %x from %x", pl.plogx_status, flags);
1281                 msg = buf;
1282                 break;
1283         }
1284         if (msg) {
1285                 isp_prt(isp, lev, "Chan %d PLOGX PortID 0x%06x to N-Port handle 0x%x: %s",
1286                     chan, portid, handle, msg);
1287         }
1288         return (retval);
1289 }
1290
1291 static int
1292 isp_getpdb(ispsoftc_t *isp, int chan, uint16_t id, isp_pdb_t *pdb)
1293 {
1294         mbreg_t mbs;
1295         union {
1296                 isp_pdb_24xx_t bill;
1297         } un;
1298
1299         MBSINIT(&mbs, MBOX_GET_PORT_DB,
1300             MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_PARAM_ERROR), 250000);
1301         mbs.ibits = (1 << 9)|(1 << 10);
1302         mbs.param[1] = id;
1303         mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
1304         mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
1305         mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
1306         mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
1307         mbs.param[9] = chan;
1308         MEMORYBARRIER(isp, SYNC_IFORDEV, 0, sizeof(un), chan);
1309
1310         isp_mboxcmd(isp, &mbs);
1311         if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
1312                 return (mbs.param[0] | (mbs.param[1] << 16));
1313
1314         MEMORYBARRIER(isp, SYNC_IFORCPU, 0, sizeof(un), chan);
1315         isp_get_pdb_24xx(isp, isp->isp_iocb, &un.bill);
1316         pdb->handle = un.bill.pdb_handle;
1317         pdb->prli_word0 = un.bill.pdb_prli_svc0;
1318         pdb->prli_word3 = un.bill.pdb_prli_svc3;
1319         pdb->portid = BITS2WORD_24XX(un.bill.pdb_portid_bits);
1320         ISP_MEMCPY(pdb->portname, un.bill.pdb_portname, 8);
1321         ISP_MEMCPY(pdb->nodename, un.bill.pdb_nodename, 8);
1322         isp_prt(isp, ISP_LOGDEBUG0,
1323             "Chan %d handle 0x%x Port 0x%06x flags 0x%x curstate %x laststate %x",
1324             chan, id, pdb->portid, un.bill.pdb_flags,
1325             un.bill.pdb_curstate, un.bill.pdb_laststate);
1326
1327         if (un.bill.pdb_curstate < PDB2400_STATE_PLOGI_DONE || un.bill.pdb_curstate > PDB2400_STATE_LOGGED_IN) {
1328                 mbs.param[0] = MBOX_NOT_LOGGED_IN;
1329                 return (mbs.param[0]);
1330         }
1331         return (0);
1332 }
1333
1334 static int
1335 isp_gethandles(ispsoftc_t *isp, int chan, uint16_t *handles, int *num, int loop)
1336 {
1337         fcparam *fcp = FCPARAM(isp, chan);
1338         mbreg_t mbs;
1339         isp_pnhle_24xx_t el4, *elp4;
1340         int i, j;
1341         uint32_t p;
1342
1343         MBSINIT(&mbs, MBOX_GET_ID_LIST, MBLOGALL, 250000);
1344         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1345         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1346         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1347         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1348         mbs.param[8] = ISP_FC_SCRLEN;
1349         mbs.param[9] = chan;
1350         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
1351                 isp_prt(isp, ISP_LOGERR, sacq);
1352                 return (-1);
1353         }
1354         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, ISP_FC_SCRLEN, chan);
1355         isp_mboxcmd(isp, &mbs);
1356         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1357                 FC_SCRATCH_RELEASE(isp, chan);
1358                 return (mbs.param[0] | (mbs.param[1] << 16));
1359         }
1360         MEMORYBARRIER(isp, SYNC_SFORCPU, 0, ISP_FC_SCRLEN, chan);
1361         elp4 = fcp->isp_scratch;
1362         for (i = 0, j = 0; i < mbs.param[1] && j < *num; i++) {
1363                 isp_get_pnhle_24xx(isp, &elp4[i], &el4);
1364                 p = el4.pnhle_port_id_lo | (el4.pnhle_port_id_hi << 16);
1365                 if (loop && (p >> 8) != (fcp->isp_portid >> 8))
1366                         continue;
1367                 handles[j++] = el4.pnhle_handle;
1368         }
1369         *num = j;
1370         FC_SCRATCH_RELEASE(isp, chan);
1371         return (0);
1372 }
1373
1374 static void
1375 isp_dump_chip_portdb(ispsoftc_t *isp, int chan)
1376 {
1377         isp_pdb_t pdb;
1378         uint16_t nphdl;
1379
1380         isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d chip port dump", chan);
1381         for (nphdl = 0; nphdl != NPH_MAX_2K; nphdl++) {
1382                 if (isp_getpdb(isp, chan, nphdl, &pdb)) {
1383                         continue;
1384                 }
1385                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d Handle 0x%04x "
1386                     "PortID 0x%06x WWPN 0x%02x%02x%02x%02x%02x%02x%02x%02x",
1387                     chan, nphdl, pdb.portid, pdb.portname[0], pdb.portname[1],
1388                     pdb.portname[2], pdb.portname[3], pdb.portname[4],
1389                     pdb.portname[5], pdb.portname[6], pdb.portname[7]);
1390         }
1391 }
1392
1393 static uint64_t
1394 isp_get_wwn(ispsoftc_t *isp, int chan, int nphdl, int nodename)
1395 {
1396         uint64_t wwn = INI_NONE;
1397         mbreg_t mbs;
1398
1399         MBSINIT(&mbs, MBOX_GET_PORT_NAME,
1400             MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_PARAM_ERROR), 500000);
1401         mbs.param[1] = nphdl;
1402         if (nodename)
1403                 mbs.param[10] = 1;
1404         mbs.param[9] = chan;
1405         isp_mboxcmd(isp, &mbs);
1406         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1407                 return (wwn);
1408         }
1409         wwn = (((uint64_t)(mbs.param[2] >> 8))  << 56) |
1410               (((uint64_t)(mbs.param[2] & 0xff))<< 48) |
1411               (((uint64_t)(mbs.param[3] >> 8))  << 40) |
1412               (((uint64_t)(mbs.param[3] & 0xff))<< 32) |
1413               (((uint64_t)(mbs.param[6] >> 8))  << 24) |
1414               (((uint64_t)(mbs.param[6] & 0xff))<< 16) |
1415               (((uint64_t)(mbs.param[7] >> 8))  <<  8) |
1416               (((uint64_t)(mbs.param[7] & 0xff)));
1417         return (wwn);
1418 }
1419
1420 /*
1421  * Make sure we have good FC link.
1422  */
1423
1424 static int
1425 isp_fclink_test(ispsoftc_t *isp, int chan, int usdelay)
1426 {
1427         mbreg_t mbs;
1428         int i, r, topo;
1429         fcparam *fcp;
1430         isp_pdb_t pdb;
1431         NANOTIME_T hra, hrb;
1432
1433         fcp = FCPARAM(isp, chan);
1434
1435         if (fcp->isp_loopstate < LOOP_HAVE_LINK)
1436                 return (-1);
1437         if (fcp->isp_loopstate >= LOOP_LTEST_DONE)
1438                 return (0);
1439
1440         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test", chan);
1441
1442         /*
1443          * Wait up to N microseconds for F/W to go to a ready state.
1444          */
1445         GET_NANOTIME(&hra);
1446         while (1) {
1447                 isp_change_fw_state(isp, chan, isp_fw_state(isp, chan));
1448                 if (fcp->isp_fwstate == FW_READY) {
1449                         break;
1450                 }
1451                 if (fcp->isp_loopstate < LOOP_HAVE_LINK)
1452                         goto abort;
1453                 GET_NANOTIME(&hrb);
1454                 if ((NANOTIME_SUB(&hrb, &hra) / 1000 + 1000 >= usdelay))
1455                         break;
1456                 ISP_SLEEP(isp, 1000);
1457         }
1458         if (fcp->isp_fwstate != FW_READY) {
1459                 isp_prt(isp, ISP_LOG_SANCFG,
1460                     "Chan %d Firmware is not ready (%s)",
1461                     chan, isp_fc_fw_statename(fcp->isp_fwstate));
1462                 return (-1);
1463         }
1464
1465         /*
1466          * Get our Loop ID and Port ID.
1467          */
1468         MBSINIT(&mbs, MBOX_GET_LOOP_ID, MBLOGALL, 0);
1469         mbs.param[9] = chan;
1470         isp_mboxcmd(isp, &mbs);
1471         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1472                 return (-1);
1473         }
1474
1475         topo = (int) mbs.param[6];
1476         if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB)
1477                 topo = TOPO_PTP_STUB;
1478         fcp->isp_topo = topo;
1479         fcp->isp_portid = mbs.param[2] | (mbs.param[3] << 16);
1480
1481         if (!TOPO_IS_FABRIC(fcp->isp_topo)) {
1482                 fcp->isp_loopid = mbs.param[1] & 0xff;
1483         } else if (fcp->isp_topo != TOPO_F_PORT) {
1484                 uint8_t alpa = fcp->isp_portid;
1485
1486                 for (i = 0; alpa_map[i]; i++) {
1487                         if (alpa_map[i] == alpa)
1488                                 break;
1489                 }
1490                 if (alpa_map[i])
1491                         fcp->isp_loopid = i;
1492         }
1493
1494 #if 0
1495         fcp->isp_loopstate = LOOP_HAVE_ADDR;
1496 #endif
1497         fcp->isp_loopstate = LOOP_TESTING_LINK;
1498
1499         if (fcp->isp_topo == TOPO_F_PORT || fcp->isp_topo == TOPO_FL_PORT) {
1500                 r = isp_getpdb(isp, chan, NPH_FL_ID, &pdb);
1501                 if (r != 0 || pdb.portid == 0) {
1502                         isp_prt(isp, ISP_LOGWARN,
1503                             "fabric topology, but cannot get info about fabric controller (0x%x)", r);
1504                         fcp->isp_topo = TOPO_PTP_STUB;
1505                         goto not_on_fabric;
1506                 }
1507
1508                 fcp->isp_fabric_params = mbs.param[7];
1509                 fcp->isp_sns_hdl = NPH_SNS_ID;
1510                 r = isp_register_fc4_type(isp, chan);
1511                 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
1512                         goto abort;
1513                 if (r != 0)
1514                         goto not_on_fabric;
1515                 r = isp_register_fc4_features_24xx(isp, chan);
1516                 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
1517                         goto abort;
1518                 if (r != 0)
1519                         goto not_on_fabric;
1520                 r = isp_register_port_name_24xx(isp, chan);
1521                 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
1522                         goto abort;
1523                 if (r != 0)
1524                         goto not_on_fabric;
1525                 isp_register_node_name_24xx(isp, chan);
1526                 if (fcp->isp_loopstate < LOOP_TESTING_LINK)
1527                         goto abort;
1528         }
1529
1530 not_on_fabric:
1531         /* Get link speed. */
1532         fcp->isp_gbspeed = 1;
1533         MBSINIT(&mbs, MBOX_GET_SET_DATA_RATE, MBLOGALL, 3000000);
1534         mbs.param[1] = MBGSD_GET_RATE;
1535         /* mbs.param[2] undefined if we're just getting rate */
1536         isp_mboxcmd(isp, &mbs);
1537         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1538                 if (mbs.param[1] == MBGSD_10GB)
1539                         fcp->isp_gbspeed = 10;
1540                 else if (mbs.param[1] == MBGSD_32GB)
1541                         fcp->isp_gbspeed = 32;
1542                 else if (mbs.param[1] == MBGSD_16GB)
1543                         fcp->isp_gbspeed = 16;
1544                 else if (mbs.param[1] == MBGSD_8GB)
1545                         fcp->isp_gbspeed = 8;
1546                 else if (mbs.param[1] == MBGSD_4GB)
1547                         fcp->isp_gbspeed = 4;
1548                 else if (mbs.param[1] == MBGSD_2GB)
1549                         fcp->isp_gbspeed = 2;
1550                 else if (mbs.param[1] == MBGSD_1GB)
1551                         fcp->isp_gbspeed = 1;
1552         }
1553
1554         if (fcp->isp_loopstate < LOOP_TESTING_LINK) {
1555 abort:
1556                 isp_prt(isp, ISP_LOG_SANCFG,
1557                     "Chan %d FC link test aborted", chan);
1558                 return (1);
1559         }
1560         fcp->isp_loopstate = LOOP_LTEST_DONE;
1561         isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
1562             "Chan %d WWPN %016jx WWNN %016jx",
1563             chan, (uintmax_t)fcp->isp_wwpn, (uintmax_t)fcp->isp_wwnn);
1564         isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
1565             "Chan %d %dGb %s PortID 0x%06x LoopID 0x%02x",
1566             chan, fcp->isp_gbspeed, isp_fc_toponame(fcp), fcp->isp_portid,
1567             fcp->isp_loopid);
1568         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test done", chan);
1569         return (0);
1570 }
1571
1572 /*
1573  * Complete the synchronization of our Port Database.
1574  *
1575  * At this point, we've scanned the local loop (if any) and the fabric
1576  * and performed fabric logins on all new devices.
1577  *
1578  * Our task here is to go through our port database removing any entities
1579  * that are still marked probational (issuing PLOGO for ones which we had
1580  * PLOGI'd into) or are dead, and notifying upper layers about new/changed
1581  * devices.
1582  */
1583 static int
1584 isp_pdb_sync(ispsoftc_t *isp, int chan)
1585 {
1586         fcparam *fcp = FCPARAM(isp, chan);
1587         fcportdb_t *lp;
1588         uint16_t dbidx;
1589
1590         if (fcp->isp_loopstate < LOOP_FSCAN_DONE)
1591                 return (-1);
1592         if (fcp->isp_loopstate >= LOOP_READY)
1593                 return (0);
1594
1595         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync", chan);
1596
1597         fcp->isp_loopstate = LOOP_SYNCING_PDB;
1598
1599         for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
1600                 lp = &fcp->portdb[dbidx];
1601
1602                 if (lp->state == FC_PORTDB_STATE_NIL)
1603                         continue;
1604                 if (lp->probational && lp->state != FC_PORTDB_STATE_ZOMBIE)
1605                         lp->state = FC_PORTDB_STATE_DEAD;
1606                 switch (lp->state) {
1607                 case FC_PORTDB_STATE_DEAD:
1608                         lp->state = FC_PORTDB_STATE_NIL;
1609                         isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
1610                         if ((lp->portid & 0xffff00) != 0) {
1611                                 (void) isp_plogx(isp, chan, lp->handle,
1612                                     lp->portid,
1613                                     PLOGX_FLG_CMD_LOGO |
1614                                     PLOGX_FLG_IMPLICIT |
1615                                     PLOGX_FLG_FREE_NPHDL);
1616                         }
1617                         /*
1618                          * Note that we might come out of this with our state
1619                          * set to FC_PORTDB_STATE_ZOMBIE.
1620                          */
1621                         break;
1622                 case FC_PORTDB_STATE_NEW:
1623                         lp->state = FC_PORTDB_STATE_VALID;
1624                         isp_async(isp, ISPASYNC_DEV_ARRIVED, chan, lp);
1625                         break;
1626                 case FC_PORTDB_STATE_CHANGED:
1627                         lp->state = FC_PORTDB_STATE_VALID;
1628                         isp_async(isp, ISPASYNC_DEV_CHANGED, chan, lp);
1629                         lp->portid = lp->new_portid;
1630                         lp->prli_word0 = lp->new_prli_word0;
1631                         lp->prli_word3 = lp->new_prli_word3;
1632                         break;
1633                 case FC_PORTDB_STATE_VALID:
1634                         isp_async(isp, ISPASYNC_DEV_STAYED, chan, lp);
1635                         break;
1636                 case FC_PORTDB_STATE_ZOMBIE:
1637                         break;
1638                 default:
1639                         isp_prt(isp, ISP_LOGWARN,
1640                             "isp_pdb_sync: state %d for idx %d",
1641                             lp->state, dbidx);
1642                         isp_dump_portdb(isp, chan);
1643                 }
1644         }
1645
1646         if (fcp->isp_loopstate < LOOP_SYNCING_PDB) {
1647                 isp_prt(isp, ISP_LOG_SANCFG,
1648                     "Chan %d FC PDB sync aborted", chan);
1649                 return (1);
1650         }
1651
1652         fcp->isp_loopstate = LOOP_READY;
1653         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync done", chan);
1654         return (0);
1655 }
1656
1657 static void
1658 isp_pdb_add_update(ispsoftc_t *isp, int chan, isp_pdb_t *pdb)
1659 {
1660         fcportdb_t *lp;
1661         uint64_t wwnn, wwpn;
1662
1663         MAKE_WWN_FROM_NODE_NAME(wwnn, pdb->nodename);
1664         MAKE_WWN_FROM_NODE_NAME(wwpn, pdb->portname);
1665
1666         /* Search port database for the same WWPN. */
1667         if (isp_find_pdb_by_wwpn(isp, chan, wwpn, &lp)) {
1668                 if (!lp->probational) {
1669                         isp_prt(isp, ISP_LOGERR,
1670                             "Chan %d Port 0x%06x@0x%04x [%d] is not probational (0x%x)",
1671                             chan, lp->portid, lp->handle,
1672                             FC_PORTDB_TGT(isp, chan, lp), lp->state);
1673                         isp_dump_portdb(isp, chan);
1674                         return;
1675                 }
1676                 lp->probational = 0;
1677                 lp->node_wwn = wwnn;
1678
1679                 /* Old device, nothing new. */
1680                 if (lp->portid == pdb->portid &&
1681                     lp->handle == pdb->handle &&
1682                     lp->prli_word3 == pdb->prli_word3 &&
1683                     ((pdb->prli_word0 & PRLI_WD0_EST_IMAGE_PAIR) ==
1684                      (lp->prli_word0 & PRLI_WD0_EST_IMAGE_PAIR))) {
1685                         if (lp->state != FC_PORTDB_STATE_NEW)
1686                                 lp->state = FC_PORTDB_STATE_VALID;
1687                         isp_prt(isp, ISP_LOG_SANCFG,
1688                             "Chan %d Port 0x%06x@0x%04x is valid",
1689                             chan, pdb->portid, pdb->handle);
1690                         return;
1691                 }
1692
1693                 /* Something has changed. */
1694                 lp->state = FC_PORTDB_STATE_CHANGED;
1695                 lp->handle = pdb->handle;
1696                 lp->new_portid = pdb->portid;
1697                 lp->new_prli_word0 = pdb->prli_word0;
1698                 lp->new_prli_word3 = pdb->prli_word3;
1699                 isp_prt(isp, ISP_LOG_SANCFG,
1700                     "Chan %d Port 0x%06x@0x%04x is changed",
1701                     chan, pdb->portid, pdb->handle);
1702                 return;
1703         }
1704
1705         /* It seems like a new port. Find an empty slot for it. */
1706         if (!isp_find_pdb_empty(isp, chan, &lp)) {
1707                 isp_prt(isp, ISP_LOGERR, "Chan %d out of portdb entries", chan);
1708                 return;
1709         }
1710
1711         ISP_MEMZERO(lp, sizeof (fcportdb_t));
1712         lp->probational = 0;
1713         lp->state = FC_PORTDB_STATE_NEW;
1714         lp->portid = lp->new_portid = pdb->portid;
1715         lp->prli_word0 = lp->new_prli_word0 = pdb->prli_word0;
1716         lp->prli_word3 = lp->new_prli_word3 = pdb->prli_word3;
1717         lp->handle = pdb->handle;
1718         lp->port_wwn = wwpn;
1719         lp->node_wwn = wwnn;
1720         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Port 0x%06x@0x%04x is new",
1721             chan, pdb->portid, pdb->handle);
1722 }
1723
1724 /*
1725  * Scan local loop for devices.
1726  */
1727 static int
1728 isp_scan_loop(ispsoftc_t *isp, int chan)
1729 {
1730         fcparam *fcp = FCPARAM(isp, chan);
1731         int idx, lim, r;
1732         isp_pdb_t pdb;
1733         uint16_t *handles;
1734         uint16_t handle;
1735
1736         if (fcp->isp_loopstate < LOOP_LTEST_DONE)
1737                 return (-1);
1738         if (fcp->isp_loopstate >= LOOP_LSCAN_DONE)
1739                 return (0);
1740
1741         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan", chan);
1742         fcp->isp_loopstate = LOOP_SCANNING_LOOP;
1743         if (TOPO_IS_FABRIC(fcp->isp_topo)) {
1744                 isp_prt(isp, ISP_LOG_SANCFG,
1745                     "Chan %d FC loop scan done (no loop)", chan);
1746                 fcp->isp_loopstate = LOOP_LSCAN_DONE;
1747                 return (0);
1748         }
1749
1750         handles = (uint16_t *)fcp->isp_scanscratch;
1751         lim = ISP_FC_SCRLEN / 2;
1752         r = isp_gethandles(isp, chan, handles, &lim, 1);
1753         if (r != 0) {
1754                 isp_prt(isp, ISP_LOG_SANCFG,
1755                     "Chan %d Getting list of handles failed with %x", chan, r);
1756                 isp_prt(isp, ISP_LOG_SANCFG,
1757                     "Chan %d FC loop scan done (bad)", chan);
1758                 return (-1);
1759         }
1760
1761         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Got %d handles",
1762             chan, lim);
1763
1764         /*
1765          * Run through the list and get the port database info for each one.
1766          */
1767         isp_mark_portdb(isp, chan);
1768         for (idx = 0; idx < lim; idx++) {
1769                 handle = handles[idx];
1770
1771                 /*
1772                  * Don't scan "special" ids.
1773                  */
1774                 if (handle >= NPH_RESERVED)
1775                         continue;
1776
1777                 /*
1778                  * Get the port database entity for this index.
1779                  */
1780                 r = isp_getpdb(isp, chan, handle, &pdb);
1781                 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
1782 abort:
1783                         isp_prt(isp, ISP_LOG_SANCFG,
1784                             "Chan %d FC loop scan aborted", chan);
1785                         return (1);
1786                 }
1787                 if (r != 0) {
1788                         isp_prt(isp, ISP_LOGDEBUG1,
1789                             "Chan %d FC Scan Loop handle %d returned %x",
1790                             chan, handle, r);
1791                         continue;
1792                 }
1793
1794                 isp_pdb_add_update(isp, chan, &pdb);
1795         }
1796         if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
1797                 goto abort;
1798         fcp->isp_loopstate = LOOP_LSCAN_DONE;
1799         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan done", chan);
1800         return (0);
1801 }
1802
1803 static int
1804 isp_ct_passthru(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
1805 {
1806         fcparam *fcp = FCPARAM(isp, chan);
1807         isp_ct_pt_t pt;
1808         int retval;
1809
1810         if (isp->isp_dblev & ISP_LOGDEBUG1)
1811                 isp_print_bytes(isp, "CT request", cmd_bcnt, fcp->isp_scratch);
1812
1813         /*
1814          * Build a Passthrough IOCB in memory.
1815          */
1816         ISP_MEMZERO(&pt, sizeof(pt));
1817         pt.ctp_header.rqs_entry_count = 1;
1818         pt.ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
1819         pt.ctp_nphdl = fcp->isp_sns_hdl;
1820         pt.ctp_cmd_cnt = 1;
1821         pt.ctp_vpidx = ISP_GET_VPIDX(isp, chan);
1822         pt.ctp_time = 10;
1823         pt.ctp_rsp_cnt = 1;
1824         pt.ctp_rsp_bcnt = rsp_bcnt;
1825         pt.ctp_cmd_bcnt = cmd_bcnt;
1826         pt.ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma);
1827         pt.ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma);
1828         pt.ctp_dataseg[0].ds_count = cmd_bcnt;
1829         pt.ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma);
1830         pt.ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma);
1831         pt.ctp_dataseg[1].ds_count = rsp_bcnt;
1832
1833         retval = isp_exec_entry_queue(isp, &pt, &pt, 2 * pt.ctp_time);
1834         if (retval != 0) {
1835                 isp_prt(isp, ISP_LOGERR, "%s: CTP of chan %d error %d",
1836                     __func__, chan, retval);
1837                 return (retval);
1838         }
1839
1840         if (pt.ctp_status && pt.ctp_status != RQCS_DATA_UNDERRUN) {
1841                 isp_prt(isp, ISP_LOGWARN,
1842                     "Chan %d CT pass-through returned 0x%x",
1843                     chan, pt.ctp_status);
1844                 return (-1);
1845         }
1846
1847         if (isp->isp_dblev & ISP_LOGDEBUG1)
1848                 isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
1849
1850         return (0);
1851 }
1852
1853 /*
1854  * Scan the fabric for devices and add them to our port database.
1855  *
1856  * Use the GID_PT command to get list of all Nx_Port IDs SNS knows.
1857  * Use GFF_ID and GFT_ID to check port type (FCP) and features (target).
1858  *
1859  * We use CT Pass-through IOCB.
1860  */
1861 #define GIDLEN  ISP_FC_SCRLEN
1862 #define NGENT   ((GIDLEN - 16) >> 2)
1863
1864 static int
1865 isp_gid_pt(ispsoftc_t *isp, int chan)
1866 {
1867         fcparam *fcp = FCPARAM(isp, chan);
1868         ct_hdr_t ct;
1869         uint8_t *scp = fcp->isp_scratch;
1870
1871         isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GID_PT", chan);
1872         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
1873                 isp_prt(isp, ISP_LOGERR, sacq);
1874                 return (-1);
1875         }
1876
1877         /* Build the CT command and execute via pass-through. */
1878         ISP_MEMZERO(&ct, sizeof (ct));
1879         ct.ct_revision = CT_REVISION;
1880         ct.ct_fcs_type = CT_FC_TYPE_FC;
1881         ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
1882         ct.ct_cmd_resp = SNS_GID_PT;
1883         ct.ct_bcnt_resid = (GIDLEN - 16) >> 2;
1884         isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
1885         scp[sizeof(ct)] = 0x7f;         /* Port Type = Nx_Port */
1886         scp[sizeof(ct)+1] = 0;          /* Domain_ID = any */
1887         scp[sizeof(ct)+2] = 0;          /* Area_ID = any */
1888         scp[sizeof(ct)+3] = 0;          /* Flags = no Area_ID */
1889
1890         if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t), GIDLEN)) {
1891                 FC_SCRATCH_RELEASE(isp, chan);
1892                 return (-1);
1893         }
1894
1895         isp_get_gid_xx_response(isp, (sns_gid_xx_rsp_t *)scp,
1896             (sns_gid_xx_rsp_t *)fcp->isp_scanscratch, NGENT);
1897         FC_SCRATCH_RELEASE(isp, chan);
1898         return (0);
1899 }
1900
1901 static int
1902 isp_gff_id(ispsoftc_t *isp, int chan, uint32_t portid)
1903 {
1904         fcparam *fcp = FCPARAM(isp, chan);
1905         ct_hdr_t ct;
1906         uint32_t *rp;
1907         uint8_t *scp = fcp->isp_scratch;
1908         sns_gff_id_rsp_t rsp;
1909         int i, res = -1;
1910
1911         if (!fcp->isp_use_gff_id)       /* User may block GFF_ID use. */
1912                 return (res);
1913
1914         isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFF_ID", chan);
1915         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
1916                 isp_prt(isp, ISP_LOGERR, sacq);
1917                 return (res);
1918         }
1919
1920         /* Build the CT command and execute via pass-through. */
1921         ISP_MEMZERO(&ct, sizeof (ct));
1922         ct.ct_revision = CT_REVISION;
1923         ct.ct_fcs_type = CT_FC_TYPE_FC;
1924         ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
1925         ct.ct_cmd_resp = SNS_GFF_ID;
1926         ct.ct_bcnt_resid = (SNS_GFF_ID_RESP_SIZE - sizeof(ct)) / 4;
1927         isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
1928         rp = (uint32_t *) &scp[sizeof(ct)];
1929         ISP_IOZPUT_32(isp, portid, rp);
1930
1931         if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
1932             SNS_GFF_ID_RESP_SIZE)) {
1933                 FC_SCRATCH_RELEASE(isp, chan);
1934                 return (res);
1935         }
1936
1937         isp_get_gff_id_response(isp, (sns_gff_id_rsp_t *)scp, &rsp);
1938         if (rsp.snscb_cthdr.ct_cmd_resp == LS_ACC) {
1939                 for (i = 0; i < 32; i++) {
1940                         if (rsp.snscb_fc4_features[i] != 0) {
1941                                 res = 0;
1942                                 break;
1943                         }
1944                 }
1945                 if (((rsp.snscb_fc4_features[FC4_SCSI / 8] >>
1946                     ((FC4_SCSI % 8) * 4)) & 0x01) != 0)
1947                         res = 1;
1948                 /* Workaround for broken Brocade firmware. */
1949                 if (((ISP_SWAP32(isp, rsp.snscb_fc4_features[FC4_SCSI / 8]) >>
1950                     ((FC4_SCSI % 8) * 4)) & 0x01) != 0)
1951                         res = 1;
1952         }
1953         FC_SCRATCH_RELEASE(isp, chan);
1954         isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFF_ID result is %d", chan, res);
1955         return (res);
1956 }
1957
1958 static int
1959 isp_gft_id(ispsoftc_t *isp, int chan, uint32_t portid)
1960 {
1961         fcparam *fcp = FCPARAM(isp, chan);
1962         ct_hdr_t ct;
1963         uint32_t *rp;
1964         uint8_t *scp = fcp->isp_scratch;
1965         sns_gft_id_rsp_t rsp;
1966         int i, res = -1;
1967
1968         if (!fcp->isp_use_gft_id)       /* User may block GFT_ID use. */
1969                 return (res);
1970
1971         isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFT_ID", chan);
1972         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
1973                 isp_prt(isp, ISP_LOGERR, sacq);
1974                 return (res);
1975         }
1976
1977         /* Build the CT command and execute via pass-through. */
1978         ISP_MEMZERO(&ct, sizeof (ct));
1979         ct.ct_revision = CT_REVISION;
1980         ct.ct_fcs_type = CT_FC_TYPE_FC;
1981         ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
1982         ct.ct_cmd_resp = SNS_GFT_ID;
1983         ct.ct_bcnt_resid = (SNS_GFT_ID_RESP_SIZE - sizeof(ct)) / 4;
1984         isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
1985         rp = (uint32_t *) &scp[sizeof(ct)];
1986         ISP_IOZPUT_32(isp, portid, rp);
1987
1988         if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
1989             SNS_GFT_ID_RESP_SIZE)) {
1990                 FC_SCRATCH_RELEASE(isp, chan);
1991                 return (res);
1992         }
1993
1994         isp_get_gft_id_response(isp, (sns_gft_id_rsp_t *)scp, &rsp);
1995         if (rsp.snscb_cthdr.ct_cmd_resp == LS_ACC) {
1996                 for (i = 0; i < 8; i++) {
1997                         if (rsp.snscb_fc4_types[i] != 0) {
1998                                 res = 0;
1999                                 break;
2000                         }
2001                 }
2002                 if (((rsp.snscb_fc4_types[FC4_SCSI / 32] >>
2003                     (FC4_SCSI % 32)) & 0x01) != 0)
2004                         res = 1;
2005         }
2006         FC_SCRATCH_RELEASE(isp, chan);
2007         isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFT_ID result is %d", chan, res);
2008         return (res);
2009 }
2010
2011 static int
2012 isp_scan_fabric(ispsoftc_t *isp, int chan)
2013 {
2014         fcparam *fcp = FCPARAM(isp, chan);
2015         fcportdb_t *lp;
2016         uint32_t portid;
2017         isp_pdb_t pdb;
2018         int portidx, portlim, r;
2019         sns_gid_xx_rsp_t *rs;
2020
2021         if (fcp->isp_loopstate < LOOP_LSCAN_DONE)
2022                 return (-1);
2023         if (fcp->isp_loopstate >= LOOP_FSCAN_DONE)
2024                 return (0);
2025
2026         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan", chan);
2027         fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
2028         if (!TOPO_IS_FABRIC(fcp->isp_topo)) {
2029                 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2030                 isp_prt(isp, ISP_LOG_SANCFG,
2031                     "Chan %d FC fabric scan done (no fabric)", chan);
2032                 return (0);
2033         }
2034
2035         if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC) {
2036 abort:
2037                 FC_SCRATCH_RELEASE(isp, chan);
2038                 isp_prt(isp, ISP_LOG_SANCFG,
2039                     "Chan %d FC fabric scan aborted", chan);
2040                 return (1);
2041         }
2042
2043         /*
2044          * Make sure we still are logged into the fabric controller.
2045          */
2046         r = isp_getpdb(isp, chan, NPH_FL_ID, &pdb);
2047         if ((r & 0xffff) == MBOX_NOT_LOGGED_IN) {
2048                 isp_dump_chip_portdb(isp, chan);
2049         }
2050         if (r) {
2051                 fcp->isp_loopstate = LOOP_LTEST_DONE;
2052 fail:
2053                 isp_prt(isp, ISP_LOG_SANCFG,
2054                     "Chan %d FC fabric scan done (bad)", chan);
2055                 return (-1);
2056         }
2057
2058         /* Get list of port IDs from SNS. */
2059         r = isp_gid_pt(isp, chan);
2060         if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
2061                 goto abort;
2062         if (r > 0) {
2063                 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2064                 return (-1);
2065         } else if (r < 0) {
2066                 fcp->isp_loopstate = LOOP_LTEST_DONE;   /* try again */
2067                 return (-1);
2068         }
2069
2070         rs = (sns_gid_xx_rsp_t *) fcp->isp_scanscratch;
2071         if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
2072                 goto abort;
2073         if (rs->snscb_cthdr.ct_cmd_resp != LS_ACC) {
2074                 int level;
2075                 /* FC-4 Type and Port Type not registered are not errors. */
2076                 if (rs->snscb_cthdr.ct_reason == 9 &&
2077                     (rs->snscb_cthdr.ct_explanation == 0x07 ||
2078                      rs->snscb_cthdr.ct_explanation == 0x0a)) {
2079                         level = ISP_LOG_SANCFG;
2080                 } else {
2081                         level = ISP_LOGWARN;
2082                 }
2083                 isp_prt(isp, level, "Chan %d Fabric Nameserver rejected GID_PT"
2084                     " (Reason=0x%x Expl=0x%x)", chan,
2085                     rs->snscb_cthdr.ct_reason,
2086                     rs->snscb_cthdr.ct_explanation);
2087                 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2088                 return (-1);
2089         }
2090
2091         /* Check our buffer was big enough to get the full list. */
2092         for (portidx = 0; portidx < NGENT-1; portidx++) {
2093                 if (rs->snscb_ports[portidx].control & 0x80)
2094                         break;
2095         }
2096         if ((rs->snscb_ports[portidx].control & 0x80) == 0) {
2097                 isp_prt(isp, ISP_LOGWARN,
2098                     "fabric too big for scratch area: increase ISP_FC_SCRLEN");
2099         }
2100         portlim = portidx + 1;
2101         isp_prt(isp, ISP_LOG_SANCFG,
2102             "Chan %d Got %d ports back from name server", chan, portlim);
2103
2104         /* Go through the list and remove duplicate port ids. */
2105         for (portidx = 0; portidx < portlim; portidx++) {
2106                 int npidx;
2107
2108                 portid =
2109                     ((rs->snscb_ports[portidx].portid[0]) << 16) |
2110                     ((rs->snscb_ports[portidx].portid[1]) << 8) |
2111                     ((rs->snscb_ports[portidx].portid[2]));
2112
2113                 for (npidx = portidx + 1; npidx < portlim; npidx++) {
2114                         uint32_t new_portid =
2115                             ((rs->snscb_ports[npidx].portid[0]) << 16) |
2116                             ((rs->snscb_ports[npidx].portid[1]) << 8) |
2117                             ((rs->snscb_ports[npidx].portid[2]));
2118                         if (new_portid == portid) {
2119                                 break;
2120                         }
2121                 }
2122
2123                 if (npidx < portlim) {
2124                         rs->snscb_ports[npidx].portid[0] = 0;
2125                         rs->snscb_ports[npidx].portid[1] = 0;
2126                         rs->snscb_ports[npidx].portid[2] = 0;
2127                         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d removing duplicate PortID 0x%06x entry from list", chan, portid);
2128                 }
2129         }
2130
2131         /*
2132          * We now have a list of Port IDs for all FC4 SCSI devices
2133          * that the Fabric Name server knows about.
2134          *
2135          * For each entry on this list go through our port database looking
2136          * for probational entries- if we find one, then an old entry is
2137          * maybe still this one. We get some information to find out.
2138          *
2139          * Otherwise, it's a new fabric device, and we log into it
2140          * (unconditionally). After searching the entire database
2141          * again to make sure that we never ever ever ever have more
2142          * than one entry that has the same PortID or the same
2143          * WWNN/WWPN duple, we enter the device into our database.
2144          */
2145         isp_mark_portdb(isp, chan);
2146         for (portidx = 0; portidx < portlim; portidx++) {
2147                 portid = ((rs->snscb_ports[portidx].portid[0]) << 16) |
2148                          ((rs->snscb_ports[portidx].portid[1]) << 8) |
2149                          ((rs->snscb_ports[portidx].portid[2]));
2150                 isp_prt(isp, ISP_LOG_SANCFG,
2151                     "Chan %d Checking fabric port 0x%06x", chan, portid);
2152                 if (portid == 0) {
2153                         isp_prt(isp, ISP_LOG_SANCFG,
2154                             "Chan %d Port at idx %d is zero",
2155                             chan, portidx);
2156                         continue;
2157                 }
2158                 if (portid == fcp->isp_portid) {
2159                         isp_prt(isp, ISP_LOG_SANCFG,
2160                             "Chan %d Port 0x%06x is our", chan, portid);
2161                         continue;
2162                 }
2163
2164                 /* Now search the entire port database for the same portid. */
2165                 if (isp_find_pdb_by_portid(isp, chan, portid, &lp)) {
2166                         if (!lp->probational) {
2167                                 isp_prt(isp, ISP_LOGERR,
2168                                     "Chan %d Port 0x%06x@0x%04x [%d] is not probational (0x%x)",
2169                                     chan, lp->portid, lp->handle,
2170                                     FC_PORTDB_TGT(isp, chan, lp), lp->state);
2171                                 isp_dump_portdb(isp, chan);
2172                                 goto fail;
2173                         }
2174
2175                         if (lp->state == FC_PORTDB_STATE_ZOMBIE)
2176                                 goto relogin;
2177
2178                         /*
2179                          * See if we're still logged into it.
2180                          *
2181                          * If we aren't, mark it as a dead device and
2182                          * leave the new portid in the database entry
2183                          * for somebody further along to decide what to
2184                          * do (policy choice).
2185                          *
2186                          * If we are, check to see if it's the same
2187                          * device still (it should be). If for some
2188                          * reason it isn't, mark it as a changed device
2189                          * and leave the new portid and role in the
2190                          * database entry for somebody further along to
2191                          * decide what to do (policy choice).
2192                          */
2193                         r = isp_getpdb(isp, chan, lp->handle, &pdb);
2194                         if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
2195                                 goto abort;
2196                         if (r != 0) {
2197                                 lp->state = FC_PORTDB_STATE_DEAD;
2198                                 isp_prt(isp, ISP_LOG_SANCFG,
2199                                     "Chan %d Port 0x%06x handle 0x%x is dead (%d)",
2200                                     chan, portid, lp->handle, r);
2201                                 goto relogin;
2202                         }
2203
2204                         isp_pdb_add_update(isp, chan, &pdb);
2205                         continue;
2206                 }
2207
2208 relogin:
2209                 if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
2210                         isp_prt(isp, ISP_LOG_SANCFG,
2211                             "Chan %d Port 0x%06x is not logged in", chan, portid);
2212                         continue;
2213                 }
2214
2215                 r = isp_gff_id(isp, chan, portid);
2216                 if (r == 0) {
2217                         isp_prt(isp, ISP_LOG_SANCFG,
2218                             "Chan %d Port 0x%06x is not an FCP target", chan, portid);
2219                         continue;
2220                 }
2221                 if (r < 0)
2222                         r = isp_gft_id(isp, chan, portid);
2223                 if (r == 0) {
2224                         isp_prt(isp, ISP_LOG_SANCFG,
2225                             "Chan %d Port 0x%06x is not FCP", chan, portid);
2226                         continue;
2227                 }
2228
2229                 if (isp_login_device(isp, chan, portid, &pdb,
2230                     &FCPARAM(isp, 0)->isp_lasthdl)) {
2231                         if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
2232                                 goto abort;
2233                         continue;
2234                 }
2235
2236                 isp_pdb_add_update(isp, chan, &pdb);
2237         }
2238
2239         if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
2240                 goto abort;
2241         fcp->isp_loopstate = LOOP_FSCAN_DONE;
2242         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan done", chan);
2243         return (0);
2244 }
2245
2246 /*
2247  * Find an unused handle and try and use to login to a port.
2248  */
2249 static int
2250 isp_login_device(ispsoftc_t *isp, int chan, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)
2251 {
2252         int i, r;
2253         uint16_t handle;
2254
2255         handle = isp_next_handle(isp, ohp);
2256         for (i = 0; i < NPH_MAX_2K; i++) {
2257                 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
2258                         return (-1);
2259
2260                 /* Check if this handle is free. */
2261                 r = isp_getpdb(isp, chan, handle, p);
2262                 if (r == 0) {
2263                         if (p->portid != portid) {
2264                                 /* This handle is busy, try next one. */
2265                                 handle = isp_next_handle(isp, ohp);
2266                                 continue;
2267                         }
2268                         break;
2269                 }
2270                 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
2271                         return (-1);
2272
2273                 /*
2274                  * Now try and log into the device
2275                  */
2276                 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
2277                 if (r == 0) {
2278                         break;
2279                 } else if ((r & 0xffff) == MBOX_PORT_ID_USED) {
2280                         /*
2281                          * If we get here, then the firmwware still thinks we're logged into this device, but with a different
2282                          * handle. We need to break that association. We used to try and just substitute the handle, but then
2283                          * failed to get any data via isp_getpdb (below).
2284                          */
2285                         if (isp_plogx(isp, chan, r >> 16, portid, PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT | PLOGX_FLG_FREE_NPHDL)) {
2286                                 isp_prt(isp, ISP_LOGERR, "baw... logout of %x failed", r >> 16);
2287                         }
2288                         if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
2289                                 return (-1);
2290                         r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
2291                         if (r != 0)
2292                                 i = NPH_MAX_2K;
2293                         break;
2294                 } else if ((r & 0xffff) == MBOX_LOOP_ID_USED) {
2295                         /* Try the next handle. */
2296                         handle = isp_next_handle(isp, ohp);
2297                 } else {
2298                         /* Give up. */
2299                         i = NPH_MAX_2K;
2300                         break;
2301                 }
2302         }
2303
2304         if (i == NPH_MAX_2K) {
2305                 isp_prt(isp, ISP_LOGWARN, "Chan %d PLOGI 0x%06x failed", chan, portid);
2306                 return (-1);
2307         }
2308
2309         /*
2310          * If we successfully logged into it, get the PDB for it
2311          * so we can crosscheck that it is still what we think it
2312          * is and that we also have the role it plays
2313          */
2314         r = isp_getpdb(isp, chan, handle, p);
2315         if (r != 0) {
2316                 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x disappeared", chan, portid, handle);
2317                 return (-1);
2318         }
2319
2320         if (p->handle != handle || p->portid != portid) {
2321                 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
2322                     chan, portid, handle, p->portid, p->handle);
2323                 return (-1);
2324         }
2325         return (0);
2326 }
2327
2328 static int
2329 isp_register_fc4_type(ispsoftc_t *isp, int chan)
2330 {
2331         fcparam *fcp = FCPARAM(isp, chan);
2332         rft_id_t rp;
2333         ct_hdr_t *ct = &rp.rftid_hdr;
2334         uint8_t *scp = fcp->isp_scratch;
2335
2336         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2337                 isp_prt(isp, ISP_LOGERR, sacq);
2338                 return (-1);
2339         }
2340
2341         /* Build the CT command and execute via pass-through. */
2342         ISP_MEMZERO(&rp, sizeof(rp));
2343         ct->ct_revision = CT_REVISION;
2344         ct->ct_fcs_type = CT_FC_TYPE_FC;
2345         ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
2346         ct->ct_cmd_resp = SNS_RFT_ID;
2347         ct->ct_bcnt_resid = (sizeof (rft_id_t) - sizeof (ct_hdr_t)) >> 2;
2348         rp.rftid_portid[0] = fcp->isp_portid >> 16;
2349         rp.rftid_portid[1] = fcp->isp_portid >> 8;
2350         rp.rftid_portid[2] = fcp->isp_portid;
2351         rp.rftid_fc4types[FC4_SCSI >> 5] = 1 << (FC4_SCSI & 0x1f);
2352         isp_put_rft_id(isp, &rp, (rft_id_t *)scp);
2353
2354         if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
2355                 FC_SCRATCH_RELEASE(isp, chan);
2356                 return (-1);
2357         }
2358
2359         isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
2360         FC_SCRATCH_RELEASE(isp, chan);
2361         if (ct->ct_cmd_resp == LS_RJT) {
2362                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "Chan %d Register FC4 Type rejected", chan);
2363                 return (-1);
2364         } else if (ct->ct_cmd_resp == LS_ACC) {
2365                 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Register FC4 Type accepted", chan);
2366         } else {
2367                 isp_prt(isp, ISP_LOGWARN, "Chan %d Register FC4 Type: 0x%x", chan, ct->ct_cmd_resp);
2368                 return (-1);
2369         }
2370         return (0);
2371 }
2372
2373 static int
2374 isp_register_fc4_features_24xx(ispsoftc_t *isp, int chan)
2375 {
2376         fcparam *fcp = FCPARAM(isp, chan);
2377         ct_hdr_t *ct;
2378         rff_id_t rp;
2379         uint8_t *scp = fcp->isp_scratch;
2380
2381         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2382                 isp_prt(isp, ISP_LOGERR, sacq);
2383                 return (-1);
2384         }
2385
2386         /*
2387          * Build the CT header and command in memory.
2388          */
2389         ISP_MEMZERO(&rp, sizeof(rp));
2390         ct = &rp.rffid_hdr;
2391         ct->ct_revision = CT_REVISION;
2392         ct->ct_fcs_type = CT_FC_TYPE_FC;
2393         ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
2394         ct->ct_cmd_resp = SNS_RFF_ID;
2395         ct->ct_bcnt_resid = (sizeof (rff_id_t) - sizeof (ct_hdr_t)) >> 2;
2396         rp.rffid_portid[0] = fcp->isp_portid >> 16;
2397         rp.rffid_portid[1] = fcp->isp_portid >> 8;
2398         rp.rffid_portid[2] = fcp->isp_portid;
2399         rp.rffid_fc4features = 0;
2400         if (fcp->role & ISP_ROLE_TARGET)
2401                 rp.rffid_fc4features |= 1;
2402         if (fcp->role & ISP_ROLE_INITIATOR)
2403                 rp.rffid_fc4features |= 2;
2404         rp.rffid_fc4type = FC4_SCSI;
2405         isp_put_rff_id(isp, &rp, (rff_id_t *)scp);
2406         if (isp->isp_dblev & ISP_LOGDEBUG1)
2407                 isp_print_bytes(isp, "CT request", sizeof(rft_id_t), scp);
2408
2409         if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
2410                 FC_SCRATCH_RELEASE(isp, chan);
2411                 return (-1);
2412         }
2413
2414         isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
2415         FC_SCRATCH_RELEASE(isp, chan);
2416         if (ct->ct_cmd_resp == LS_RJT) {
2417                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
2418                     "Chan %d Register FC4 Features rejected", chan);
2419                 return (-1);
2420         } else if (ct->ct_cmd_resp == LS_ACC) {
2421                 isp_prt(isp, ISP_LOG_SANCFG,
2422                     "Chan %d Register FC4 Features accepted", chan);
2423         } else {
2424                 isp_prt(isp, ISP_LOGWARN,
2425                     "Chan %d Register FC4 Features: 0x%x", chan, ct->ct_cmd_resp);
2426                 return (-1);
2427         }
2428         return (0);
2429 }
2430
2431 static int
2432 isp_register_port_name_24xx(ispsoftc_t *isp, int chan)
2433 {
2434         fcparam *fcp = FCPARAM(isp, chan);
2435         ct_hdr_t *ct;
2436         rspn_id_t rp;
2437         uint8_t *scp = fcp->isp_scratch;
2438         int len;
2439
2440         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2441                 isp_prt(isp, ISP_LOGERR, sacq);
2442                 return (-1);
2443         }
2444
2445         /*
2446          * Build the CT header and command in memory.
2447          */
2448         ISP_MEMZERO(&rp, sizeof(rp));
2449         ct = &rp.rspnid_hdr;
2450         ct->ct_revision = CT_REVISION;
2451         ct->ct_fcs_type = CT_FC_TYPE_FC;
2452         ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
2453         ct->ct_cmd_resp = SNS_RSPN_ID;
2454         rp.rspnid_portid[0] = fcp->isp_portid >> 16;
2455         rp.rspnid_portid[1] = fcp->isp_portid >> 8;
2456         rp.rspnid_portid[2] = fcp->isp_portid;
2457         rp.rspnid_length = 0;
2458         len = offsetof(rspn_id_t, rspnid_name);
2459         mtx_lock(&prison0.pr_mtx);
2460         rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
2461             "%s", prison0.pr_hostname[0] ? prison0.pr_hostname : "FreeBSD");
2462         mtx_unlock(&prison0.pr_mtx);
2463         rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
2464             ":%s", device_get_nameunit(isp->isp_dev));
2465         if (chan != 0) {
2466                 rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
2467                     "/%d", chan);
2468         }
2469         len += rp.rspnid_length;
2470         ct->ct_bcnt_resid = (len - sizeof(ct_hdr_t)) >> 2;
2471         isp_put_rspn_id(isp, &rp, (rspn_id_t *)scp);
2472
2473         if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
2474                 FC_SCRATCH_RELEASE(isp, chan);
2475                 return (-1);
2476         }
2477
2478         isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
2479         FC_SCRATCH_RELEASE(isp, chan);
2480         if (ct->ct_cmd_resp == LS_RJT) {
2481                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
2482                     "Chan %d Register Symbolic Port Name rejected", chan);
2483                 return (-1);
2484         } else if (ct->ct_cmd_resp == LS_ACC) {
2485                 isp_prt(isp, ISP_LOG_SANCFG,
2486                     "Chan %d Register Symbolic Port Name accepted", chan);
2487         } else {
2488                 isp_prt(isp, ISP_LOGWARN,
2489                     "Chan %d Register Symbolic Port Name: 0x%x", chan, ct->ct_cmd_resp);
2490                 return (-1);
2491         }
2492         return (0);
2493 }
2494
2495 static int
2496 isp_register_node_name_24xx(ispsoftc_t *isp, int chan)
2497 {
2498         fcparam *fcp = FCPARAM(isp, chan);
2499         ct_hdr_t *ct;
2500         rsnn_nn_t rp;
2501         uint8_t *scp = fcp->isp_scratch;
2502         int len;
2503
2504         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2505                 isp_prt(isp, ISP_LOGERR, sacq);
2506                 return (-1);
2507         }
2508
2509         /*
2510          * Build the CT header and command in memory.
2511          */
2512         ISP_MEMZERO(&rp, sizeof(rp));
2513         ct = &rp.rsnnnn_hdr;
2514         ct->ct_revision = CT_REVISION;
2515         ct->ct_fcs_type = CT_FC_TYPE_FC;
2516         ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
2517         ct->ct_cmd_resp = SNS_RSNN_NN;
2518         MAKE_NODE_NAME_FROM_WWN(rp.rsnnnn_nodename, fcp->isp_wwnn);
2519         rp.rsnnnn_length = 0;
2520         len = offsetof(rsnn_nn_t, rsnnnn_name);
2521         mtx_lock(&prison0.pr_mtx);
2522         rp.rsnnnn_length += sprintf(&scp[len + rp.rsnnnn_length],
2523             "%s", prison0.pr_hostname[0] ? prison0.pr_hostname : "FreeBSD");
2524         mtx_unlock(&prison0.pr_mtx);
2525         len += rp.rsnnnn_length;
2526         ct->ct_bcnt_resid = (len - sizeof(ct_hdr_t)) >> 2;
2527         isp_put_rsnn_nn(isp, &rp, (rsnn_nn_t *)scp);
2528
2529         if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
2530                 FC_SCRATCH_RELEASE(isp, chan);
2531                 return (-1);
2532         }
2533
2534         isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
2535         FC_SCRATCH_RELEASE(isp, chan);
2536         if (ct->ct_cmd_resp == LS_RJT) {
2537                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
2538                     "Chan %d Register Symbolic Node Name rejected", chan);
2539                 return (-1);
2540         } else if (ct->ct_cmd_resp == LS_ACC) {
2541                 isp_prt(isp, ISP_LOG_SANCFG,
2542                     "Chan %d Register Symbolic Node Name accepted", chan);
2543         } else {
2544                 isp_prt(isp, ISP_LOGWARN,
2545                     "Chan %d Register Symbolic Node Name: 0x%x", chan, ct->ct_cmd_resp);
2546                 return (-1);
2547         }
2548         return (0);
2549 }
2550
2551 static uint16_t
2552 isp_next_handle(ispsoftc_t *isp, uint16_t *ohp)
2553 {
2554         fcparam *fcp;
2555         int i, chan, wrap;
2556         uint16_t handle;
2557
2558         handle = *ohp;
2559         wrap = 0;
2560
2561 next:
2562         if (handle == NIL_HANDLE) {
2563                 handle = 0;
2564         } else {
2565                 handle++;
2566                 if (handle > NPH_RESERVED - 1) {
2567                         if (++wrap >= 2) {
2568                                 isp_prt(isp, ISP_LOGERR, "Out of port handles!");
2569                                 return (NIL_HANDLE);
2570                         }
2571                         handle = 0;
2572                 }
2573         }
2574         for (chan = 0; chan < isp->isp_nchan; chan++) {
2575                 fcp = FCPARAM(isp, chan);
2576                 if (fcp->role == ISP_ROLE_NONE)
2577                         continue;
2578                 for (i = 0; i < MAX_FC_TARG; i++) {
2579                         if (fcp->portdb[i].state != FC_PORTDB_STATE_NIL &&
2580                             fcp->portdb[i].handle == handle)
2581                                 goto next;
2582                 }
2583         }
2584         *ohp = handle;
2585         return (handle);
2586 }
2587
2588 /*
2589  * Start a command. Locking is assumed done in the caller.
2590  */
2591
2592 int
2593 isp_start(XS_T *xs)
2594 {
2595         ispsoftc_t *isp;
2596         fcparam *fcp;
2597         uint32_t cdblen;
2598         ispreqt7_t local, *reqp = &local;
2599         void *qep;
2600         fcportdb_t *lp;
2601         int target, dmaresult;
2602
2603         XS_INITERR(xs);
2604         isp = XS_ISP(xs);
2605
2606         /*
2607          * Check command CDB length, etc.. We really are limited to 16 bytes
2608          * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
2609          * but probably only if we're running fairly new firmware (we'll
2610          * let the old f/w choke on an extended command queue entry).
2611          */
2612
2613         if (XS_CDBLEN(xs) > 16 || XS_CDBLEN(xs) == 0) {
2614                 isp_prt(isp, ISP_LOGERR, "unsupported cdb length (%d, CDB[0]=0x%x)", XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
2615                 XS_SETERR(xs, HBA_REQINVAL);
2616                 return (CMD_COMPLETE);
2617         }
2618
2619         /*
2620          * Translate the target to device handle as appropriate, checking
2621          * for correct device state as well.
2622          */
2623         target = XS_TGT(xs);
2624         fcp = FCPARAM(isp, XS_CHANNEL(xs));
2625
2626         if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
2627                 isp_prt(isp, ISP_LOG_WARN1,
2628                     "%d.%d.%jx I am not an initiator",
2629                     XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
2630                 XS_SETERR(xs, HBA_SELTIMEOUT);
2631                 return (CMD_COMPLETE);
2632         }
2633
2634         if (isp->isp_state != ISP_RUNSTATE) {
2635                 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
2636                 XS_SETERR(xs, HBA_BOTCH);
2637                 return (CMD_COMPLETE);
2638         }
2639
2640         isp_prt(isp, ISP_LOGDEBUG2, "XS_TGT(xs)=%d", target);
2641         lp = &fcp->portdb[target];
2642         if (target < 0 || target >= MAX_FC_TARG ||
2643             lp->is_target == 0) {
2644                 XS_SETERR(xs, HBA_SELTIMEOUT);
2645                 return (CMD_COMPLETE);
2646         }
2647         if (fcp->isp_loopstate != LOOP_READY) {
2648                 isp_prt(isp, ISP_LOGDEBUG1,
2649                     "%d.%d.%jx loop is not ready",
2650                     XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
2651                 return (CMD_RQLATER);
2652         }
2653         if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
2654                 isp_prt(isp, ISP_LOGDEBUG1,
2655                     "%d.%d.%jx target zombie",
2656                     XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
2657                 return (CMD_RQLATER);
2658         }
2659         if (lp->state != FC_PORTDB_STATE_VALID) {
2660                 isp_prt(isp, ISP_LOGDEBUG1,
2661                     "%d.%d.%jx bad db port state 0x%x",
2662                     XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs), lp->state);
2663                 XS_SETERR(xs, HBA_SELTIMEOUT);
2664                 return (CMD_COMPLETE);
2665         }
2666
2667  start_again:
2668
2669         qep = isp_getrqentry(isp);
2670         if (qep == NULL) {
2671                 isp_prt(isp, ISP_LOG_WARN1, "Request Queue Overflow");
2672                 XS_SETERR(xs, HBA_BOTCH);
2673                 return (CMD_EAGAIN);
2674         }
2675         XS_SETERR(xs, HBA_NOERROR);
2676
2677         /*
2678          * Now see if we need to synchronize the ISP with respect to anything.
2679          * We do dual duty here (cough) for synchronizing for buses other
2680          * than which we got here to send a command to.
2681          */
2682         ISP_MEMZERO(reqp, QENTRY_LEN);
2683         if (ISP_TST_SENDMARKER(isp, XS_CHANNEL(xs))) {
2684                 isp_marker_24xx_t *m = (isp_marker_24xx_t *) reqp;
2685                 m->mrk_header.rqs_entry_count = 1;
2686                 m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
2687                 m->mrk_modifier = SYNC_ALL;
2688                 m->mrk_vphdl = XS_CHANNEL(xs);
2689                 isp_put_marker_24xx(isp, m, qep);
2690                 ISP_SYNC_REQUEST(isp);
2691                 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 0);
2692                 goto start_again;
2693         }
2694
2695         /*
2696          * NB: we do not support long CDBs (yet)
2697          */
2698         cdblen = XS_CDBLEN(xs);
2699         if (cdblen > sizeof (reqp->req_cdb)) {
2700                 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
2701                 XS_SETERR(xs, HBA_REQINVAL);
2702                 return (CMD_COMPLETE);
2703         }
2704
2705         reqp->req_header.rqs_entry_type = RQSTYPE_T7RQS;
2706         reqp->req_header.rqs_entry_count = 1;
2707         reqp->req_nphdl = lp->handle;
2708         reqp->req_time = XS_TIME(xs);
2709         be64enc(reqp->req_lun, CAM_EXTLUN_BYTE_SWIZZLE(XS_LUN(xs)));
2710         if (XS_XFRIN(xs))
2711                 reqp->req_alen_datadir = FCP_CMND_DATA_READ;
2712         else if (XS_XFROUT(xs))
2713                 reqp->req_alen_datadir = FCP_CMND_DATA_WRITE;
2714         if (XS_TAG_P(xs))
2715                 reqp->req_task_attribute = XS_TAG_TYPE(xs);
2716         else
2717                 reqp->req_task_attribute = FCP_CMND_TASK_ATTR_SIMPLE;
2718         reqp->req_task_attribute |= (XS_PRIORITY(xs) << FCP_CMND_PRIO_SHIFT) &
2719              FCP_CMND_PRIO_MASK;
2720         if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
2721                 if (FCP_NEXT_CRN(isp, &reqp->req_crn, xs)) {
2722                         isp_prt(isp, ISP_LOG_WARN1,
2723                             "%d.%d.%jx cannot generate next CRN",
2724                             XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
2725                         XS_SETERR(xs, HBA_BOTCH);
2726                         return (CMD_EAGAIN);
2727                 }
2728         }
2729         ISP_MEMCPY(reqp->req_cdb, XS_CDBP(xs), cdblen);
2730         reqp->req_dl = XS_XFRLEN(xs);
2731         reqp->req_tidlo = lp->portid;
2732         reqp->req_tidhi = lp->portid >> 16;
2733         reqp->req_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(xs));
2734
2735         /* Whew. Thankfully the same for type 7 requests */
2736         reqp->req_handle = isp_allocate_handle(isp, xs, ISP_HANDLE_INITIATOR);
2737         if (reqp->req_handle == 0) {
2738                 isp_prt(isp, ISP_LOG_WARN1, "out of xflist pointers");
2739                 XS_SETERR(xs, HBA_BOTCH);
2740                 return (CMD_EAGAIN);
2741         }
2742
2743         /*
2744          * Set up DMA and/or do any platform dependent swizzling of the request entry
2745          * so that the Qlogic F/W understands what is being asked of it.
2746          *
2747          * The callee is responsible for adding all requests at this point.
2748          */
2749         dmaresult = ISP_DMASETUP(isp, xs, reqp);
2750         if (dmaresult != 0) {
2751                 isp_destroy_handle(isp, reqp->req_handle);
2752                 /*
2753                  * dmasetup sets actual error in packet, and
2754                  * return what we were given to return.
2755                  */
2756                 return (dmaresult);
2757         }
2758         isp_xs_prt(isp, xs, ISP_LOGDEBUG0, "START cmd cdb[0]=0x%x datalen %ld", XS_CDBP(xs)[0], (long) XS_XFRLEN(xs));
2759         return (0);
2760 }
2761
2762 /*
2763  * isp control
2764  * Locks (ints blocked) assumed held.
2765  */
2766
2767 int
2768 isp_control(ispsoftc_t *isp, ispctl_t ctl, ...)
2769 {
2770         fcparam *fcp;
2771         fcportdb_t *lp;
2772         XS_T *xs;
2773         mbreg_t *mbr;
2774         int chan, tgt;
2775         uint32_t handle;
2776         va_list ap;
2777         uint8_t local[QENTRY_LEN];
2778
2779         switch (ctl) {
2780         case ISPCTL_RESET_BUS:
2781                 /*
2782                  * Issue a bus reset.
2783                  */
2784                 isp_prt(isp, ISP_LOGERR, "BUS RESET NOT IMPLEMENTED");
2785                 break;
2786
2787         case ISPCTL_RESET_DEV:
2788         {
2789                 isp24xx_tmf_t *tmf;
2790                 isp24xx_statusreq_t *sp;
2791
2792                 va_start(ap, ctl);
2793                 chan = va_arg(ap, int);
2794                 tgt = va_arg(ap, int);
2795                 va_end(ap);
2796                 fcp = FCPARAM(isp, chan);
2797
2798                 if (tgt < 0 || tgt >= MAX_FC_TARG) {
2799                         isp_prt(isp, ISP_LOGWARN, "Chan %d trying to reset bad target %d", chan, tgt);
2800                         break;
2801                 }
2802                 lp = &fcp->portdb[tgt];
2803                 if (lp->is_target == 0 || lp->state != FC_PORTDB_STATE_VALID) {
2804                         isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
2805                         break;
2806                 }
2807
2808                 tmf = (isp24xx_tmf_t *) local;
2809                 ISP_MEMZERO(tmf, QENTRY_LEN);
2810                 tmf->tmf_header.rqs_entry_type = RQSTYPE_TSK_MGMT;
2811                 tmf->tmf_header.rqs_entry_count = 1;
2812                 tmf->tmf_nphdl = lp->handle;
2813                 tmf->tmf_delay = 2;
2814                 tmf->tmf_timeout = 4;
2815                 tmf->tmf_flags = ISP24XX_TMF_TARGET_RESET;
2816                 tmf->tmf_tidlo = lp->portid;
2817                 tmf->tmf_tidhi = lp->portid >> 16;
2818                 tmf->tmf_vpidx = ISP_GET_VPIDX(isp, chan);
2819                 fcp->sendmarker = 1;
2820                 isp_prt(isp, ISP_LOGALL, "Chan %d Reset N-Port Handle 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
2821
2822                 sp = (isp24xx_statusreq_t *) local;
2823                 if (isp_exec_entry_mbox(isp, tmf, sp, 2 * tmf->tmf_timeout))
2824                         break;
2825
2826                 if (sp->req_completion_status == 0)
2827                         return (0);
2828                 isp_prt(isp, ISP_LOGWARN, "Chan %d reset of target %d returned 0x%x", chan, tgt, sp->req_completion_status);
2829                 break;
2830         }
2831         case ISPCTL_ABORT_CMD:
2832         {
2833                 isp24xx_abrt_t *ab = (isp24xx_abrt_t *)&local;
2834
2835                 va_start(ap, ctl);
2836                 xs = va_arg(ap, XS_T *);
2837                 va_end(ap);
2838
2839                 tgt = XS_TGT(xs);
2840                 chan = XS_CHANNEL(xs);
2841
2842                 handle = isp_find_handle(isp, xs);
2843                 if (handle == 0) {
2844                         isp_prt(isp, ISP_LOGWARN, "cannot find handle for command to abort");
2845                         break;
2846                 }
2847
2848                 fcp = FCPARAM(isp, chan);
2849                 if (tgt < 0 || tgt >= MAX_FC_TARG) {
2850                         isp_prt(isp, ISP_LOGWARN, "Chan %d trying to abort bad target %d", chan, tgt);
2851                         break;
2852                 }
2853                 lp = &fcp->portdb[tgt];
2854                 if (lp->is_target == 0 || lp->state != FC_PORTDB_STATE_VALID) {
2855                         isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
2856                         break;
2857                 }
2858                 isp_prt(isp, ISP_LOGALL, "Chan %d Abort Cmd for N-Port 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
2859                 ISP_MEMZERO(ab, QENTRY_LEN);
2860                 ab->abrt_header.rqs_entry_type = RQSTYPE_ABORT_IO;
2861                 ab->abrt_header.rqs_entry_count = 1;
2862                 ab->abrt_handle = lp->handle;
2863                 ab->abrt_cmd_handle = handle;
2864                 ab->abrt_tidlo = lp->portid;
2865                 ab->abrt_tidhi = lp->portid >> 16;
2866                 ab->abrt_vpidx = ISP_GET_VPIDX(isp, chan);
2867
2868                 if (isp_exec_entry_mbox(isp, ab, ab, 5))
2869                         break;
2870
2871                 if (ab->abrt_nphdl == ISP24XX_ABRT_OKAY)
2872                         return (0);
2873                 isp_prt(isp, ISP_LOGWARN, "Chan %d handle %d abort returned 0x%x", chan, tgt, ab->abrt_nphdl);
2874         }
2875         case ISPCTL_FCLINK_TEST:
2876         {
2877                 int usdelay;
2878
2879                 va_start(ap, ctl);
2880                 chan = va_arg(ap, int);
2881                 usdelay = va_arg(ap, int);
2882                 va_end(ap);
2883                 if (usdelay == 0)
2884                         usdelay = 250000;
2885                 return (isp_fclink_test(isp, chan, usdelay));
2886         }
2887         case ISPCTL_SCAN_FABRIC:
2888
2889                 va_start(ap, ctl);
2890                 chan = va_arg(ap, int);
2891                 va_end(ap);
2892                 return (isp_scan_fabric(isp, chan));
2893
2894         case ISPCTL_SCAN_LOOP:
2895
2896                 va_start(ap, ctl);
2897                 chan = va_arg(ap, int);
2898                 va_end(ap);
2899                 return (isp_scan_loop(isp, chan));
2900
2901         case ISPCTL_PDB_SYNC:
2902
2903                 va_start(ap, ctl);
2904                 chan = va_arg(ap, int);
2905                 va_end(ap);
2906                 return (isp_pdb_sync(isp, chan));
2907
2908         case ISPCTL_SEND_LIP:
2909                 break;
2910
2911         case ISPCTL_GET_PDB:
2912         {
2913                 isp_pdb_t *pdb;
2914                 va_start(ap, ctl);
2915                 chan = va_arg(ap, int);
2916                 tgt = va_arg(ap, int);
2917                 pdb = va_arg(ap, isp_pdb_t *);
2918                 va_end(ap);
2919                 return (isp_getpdb(isp, chan, tgt, pdb));
2920         }
2921         case ISPCTL_GET_NAMES:
2922         {
2923                 uint64_t *wwnn, *wwnp;
2924                 va_start(ap, ctl);
2925                 chan = va_arg(ap, int);
2926                 tgt = va_arg(ap, int);
2927                 wwnn = va_arg(ap, uint64_t *);
2928                 wwnp = va_arg(ap, uint64_t *);
2929                 va_end(ap);
2930                 if (wwnn == NULL && wwnp == NULL) {
2931                         break;
2932                 }
2933                 if (wwnn) {
2934                         *wwnn = isp_get_wwn(isp, chan, tgt, 1);
2935                         if (*wwnn == INI_NONE) {
2936                                 break;
2937                         }
2938                 }
2939                 if (wwnp) {
2940                         *wwnp = isp_get_wwn(isp, chan, tgt, 0);
2941                         if (*wwnp == INI_NONE) {
2942                                 break;
2943                         }
2944                 }
2945                 return (0);
2946         }
2947         case ISPCTL_RUN_MBOXCMD:
2948         {
2949                 va_start(ap, ctl);
2950                 mbr = va_arg(ap, mbreg_t *);
2951                 va_end(ap);
2952                 isp_mboxcmd(isp, mbr);
2953                 return (0);
2954         }
2955         case ISPCTL_PLOGX:
2956         {
2957                 isp_plcmd_t *p;
2958                 int r;
2959
2960                 va_start(ap, ctl);
2961                 p = va_arg(ap, isp_plcmd_t *);
2962                 va_end(ap);
2963
2964                 if ((p->flags & PLOGX_FLG_CMD_MASK) != PLOGX_FLG_CMD_PLOGI || (p->handle != NIL_HANDLE)) {
2965                         return (isp_plogx(isp, p->channel, p->handle, p->portid, p->flags));
2966                 }
2967                 do {
2968                         isp_next_handle(isp, &p->handle);
2969                         r = isp_plogx(isp, p->channel, p->handle, p->portid, p->flags);
2970                         if ((r & 0xffff) == MBOX_PORT_ID_USED) {
2971                                 p->handle = r >> 16;
2972                                 r = 0;
2973                                 break;
2974                         }
2975                 } while ((r & 0xffff) == MBOX_LOOP_ID_USED);
2976                 return (r);
2977         }
2978         case ISPCTL_CHANGE_ROLE:
2979         {
2980                 int role;
2981
2982                 va_start(ap, ctl);
2983                 chan = va_arg(ap, int);
2984                 role = va_arg(ap, int);
2985                 va_end(ap);
2986                 return (isp_fc_change_role(isp, chan, role));
2987         }
2988         default:
2989                 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
2990                 break;
2991
2992         }
2993         return (-1);
2994 }
2995
2996 /*
2997  * Interrupt Service Routine(s).
2998  *
2999  * External (OS) framework has done the appropriate locking,
3000  * and the locking will be held throughout this function.
3001  */
3002
3003 #ifdef  ISP_TARGET_MODE
3004 void
3005 isp_intr_atioq(ispsoftc_t *isp)
3006 {
3007         void *addr;
3008         uint32_t iptr, optr, oop;
3009
3010         iptr = ISP_READ(isp, BIU2400_ATIO_RSPINP);
3011         optr = isp->isp_atioodx;
3012         while (optr != iptr) {
3013                 oop = optr;
3014                 MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN, -1);
3015                 addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
3016                 switch (((isphdr_t *)addr)->rqs_entry_type) {
3017                 case RQSTYPE_NOTIFY:
3018                 case RQSTYPE_ATIO:
3019                 case RQSTYPE_NOTIFY_ACK:        /* Can be set to ATIO queue.*/
3020                 case RQSTYPE_ABTS_RCVD:         /* Can be set to ATIO queue.*/
3021                         (void) isp_target_notify(isp, addr, &oop,
3022                             ATIO_QUEUE_LEN(isp));
3023                         break;
3024                 case RQSTYPE_RPT_ID_ACQ:        /* Can be set to ATIO queue.*/
3025                 default:
3026                         isp_print_qentry(isp, "?ATIOQ entry?", oop, addr);
3027                         break;
3028                 }
3029                 optr = ISP_NXT_QENTRY(oop, ATIO_QUEUE_LEN(isp));
3030         }
3031         if (isp->isp_atioodx != optr) {
3032                 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, optr);
3033                 isp->isp_atioodx = optr;
3034         }
3035 }
3036 #endif
3037
3038 void
3039 isp_intr_mbox(ispsoftc_t *isp, uint16_t mbox0)
3040 {
3041         int i, obits;
3042
3043         if (!isp->isp_mboxbsy) {
3044                 isp_prt(isp, ISP_LOGWARN, "mailbox 0x%x with no waiters", mbox0);
3045                 return;
3046         }
3047         obits = isp->isp_obits;
3048         isp->isp_mboxtmp[0] = mbox0;
3049         for (i = 1; i < ISP_NMBOX(isp); i++) {
3050                 if ((obits & (1 << i)) == 0)
3051                         continue;
3052                 isp->isp_mboxtmp[i] = ISP_READ(isp, MBOX_OFF(i));
3053         }
3054         isp->isp_mboxbsy = 0;
3055 }
3056
3057 void
3058 isp_intr_respq(ispsoftc_t *isp)
3059 {
3060         XS_T *xs, *cont_xs;
3061         uint8_t qe[QENTRY_LEN];
3062         isp24xx_statusreq_t *sp = (isp24xx_statusreq_t *)qe;
3063         ispstatus_cont_t *scp = (ispstatus_cont_t *)qe;
3064         isphdr_t *hp;
3065         uint8_t *resp, *snsp, etype;
3066         uint16_t scsi_status;
3067         uint32_t iptr, cont = 0, cptr, optr, rlen, slen, sptr, totslen;
3068
3069         /*
3070          * We can't be getting this now.
3071          */
3072         if (isp->isp_state != ISP_RUNSTATE) {
3073                 isp_prt(isp, ISP_LOGINFO, "respq interrupt when not ready");
3074                 return;
3075         }
3076
3077         iptr = ISP_READ(isp, BIU2400_RSPINP);
3078         optr = isp->isp_resodx;
3079         while (optr != iptr) {
3080                 sptr = cptr = optr;
3081                 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, cptr);
3082                 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
3083
3084                 /*
3085                  * Synchronize our view of this response queue entry.
3086                  */
3087                 MEMORYBARRIER(isp, SYNC_RESULT, cptr, QENTRY_LEN, -1);
3088                 if (isp->isp_dblev & ISP_LOGDEBUG1)
3089                         isp_print_qentry(isp, "Response Queue Entry", cptr, hp);
3090                 isp_get_hdr(isp, hp, &sp->req_header);
3091
3092                 /*
3093                  * Log IOCBs rejected by the firmware.  We can't really do
3094                  * much more about them, since it just should not happen.
3095                  */
3096                 if (sp->req_header.rqs_flags & RQSFLAG_BADTYPE) {
3097                         isp_print_qentry(isp, "invalid entry type", cptr, hp);
3098                         continue;
3099                 }
3100                 if (sp->req_header.rqs_flags & RQSFLAG_BADPARAM) {
3101                         isp_print_qentry(isp, "invalid entry parameter", cptr, hp);
3102                         continue;
3103                 }
3104                 if (sp->req_header.rqs_flags & RQSFLAG_BADCOUNT) {
3105                         isp_print_qentry(isp, "invalid entry count", cptr, hp);
3106                         continue;
3107                 }
3108                 if (sp->req_header.rqs_flags & RQSFLAG_BADORDER) {
3109                         isp_print_qentry(isp, "invalid entry order", cptr, hp);
3110                         continue;
3111                 }
3112
3113                 etype = sp->req_header.rqs_entry_type;
3114
3115                 /* We expected Status Continuation, but got different IOCB. */
3116                 if (cont > 0 && etype != RQSTYPE_STATUS_CONT) {
3117                         cont = 0;
3118                         isp_done(cont_xs);
3119                 }
3120
3121                 if (isp_handle_control(isp, hp)) {
3122                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
3123                         continue;
3124                 }
3125
3126                 switch (etype) {
3127                 case RQSTYPE_RESPONSE:
3128                         isp_get_24xx_response(isp, (isp24xx_statusreq_t *)hp, sp);
3129                         break;
3130                 case RQSTYPE_MARKER:
3131                         isp_prt(isp, ISP_LOG_WARN1, "Marker Response");
3132                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
3133                         continue;
3134                 case RQSTYPE_STATUS_CONT:
3135                         isp_get_cont_response(isp, (ispstatus_cont_t *)hp, scp);
3136                         if (cont > 0) {
3137                                 slen = min(cont, sizeof(scp->req_sense_data));
3138                                 XS_SENSE_APPEND(cont_xs, scp->req_sense_data, slen);
3139                                 cont -= slen;
3140                                 if (cont == 0) {
3141                                         isp_done(cont_xs);
3142                                 } else {
3143                                         isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
3144                                             "Expecting Status Continuations for %u bytes",
3145                                             cont);
3146                                 }
3147                         } else {
3148                                 isp_prt(isp, ISP_LOG_WARN1, "Ignored Continuation Response");
3149                         }
3150                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
3151                         continue;
3152 #ifdef  ISP_TARGET_MODE
3153                 case RQSTYPE_NOTIFY_ACK:        /* Can be set to ATIO queue. */
3154                 case RQSTYPE_CTIO7:
3155                 case RQSTYPE_ABTS_RCVD:         /* Can be set to ATIO queue. */
3156                 case RQSTYPE_ABTS_RSP:
3157                         isp_target_notify(isp, hp, &cptr, RESULT_QUEUE_LEN(isp));
3158                         /* More then one IOCB could be consumed. */
3159                         while (sptr != cptr) {
3160                                 ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
3161                                 sptr = ISP_NXT_QENTRY(sptr, RESULT_QUEUE_LEN(isp));
3162                                 hp = (isphdr_t *)ISP_QUEUE_ENTRY(isp->isp_result, sptr);
3163                         }
3164                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
3165                         optr = ISP_NXT_QENTRY(cptr, RESULT_QUEUE_LEN(isp));
3166                         continue;
3167 #endif
3168                 case RQSTYPE_RPT_ID_ACQ:        /* Can be set to ATIO queue.*/
3169                         isp_handle_rpt_id_acq(isp, hp);
3170                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
3171                         continue;
3172                 default:
3173                         /* We don't know what was this -- log and skip. */
3174                         isp_prt(isp, ISP_LOGERR, notresp, etype, cptr, optr);
3175                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
3176                         continue;
3177                 }
3178
3179                 xs = isp_find_xs(isp, sp->req_handle);
3180                 if (xs == NULL) {
3181                         /*
3182                          * Only whine if this isn't the expected fallout of
3183                          * aborting the command or resetting the target.
3184                          */
3185                         if (sp->req_completion_status != RQCS_ABORTED &&
3186                             sp->req_completion_status != RQCS_RESET_OCCURRED)
3187                                 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (status 0x%x)",
3188                                     sp->req_handle, sp->req_completion_status);
3189                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
3190                         continue;
3191                 }
3192
3193                 resp = snsp = sp->req_rsp_sense;
3194                 rlen = slen = totslen = 0;
3195                 scsi_status = sp->req_scsi_status;
3196                 if (scsi_status & RQCS_RV) {
3197                         rlen = sp->req_response_len;
3198                         snsp += rlen;
3199                 }
3200                 if (scsi_status & RQCS_SV) {
3201                         totslen = sp->req_sense_len;
3202                         slen = MIN(totslen, sizeof(sp->req_rsp_sense) - rlen);
3203                 }
3204                 *XS_STSP(xs) = scsi_status & 0xff;
3205                 if (scsi_status & RQCS_RESID)
3206                         XS_SET_RESID(xs, sp->req_fcp_residual);
3207                 else
3208                         XS_SET_RESID(xs, 0);
3209
3210                 if (rlen >= 4 && resp[FCP_RSPNS_CODE_OFFSET] != 0) {
3211                         const char *ptr;
3212                         char lb[64];
3213                         const char *rnames[10] = {
3214                             "Task Management function complete",
3215                             "FCP_DATA length different than FCP_BURST_LEN",
3216                             "FCP_CMND fields invalid",
3217                             "FCP_DATA parameter mismatch with FCP_DATA_RO",
3218                             "Task Management function rejected",
3219                             "Task Management function failed",
3220                             NULL,
3221                             NULL,
3222                             "Task Management function succeeded",
3223                             "Task Management function incorrect logical unit number",
3224                         };
3225                         uint8_t code = resp[FCP_RSPNS_CODE_OFFSET];
3226                         if (code >= nitems(rnames) || rnames[code] == NULL) {
3227                                 ISP_SNPRINTF(lb, sizeof(lb),
3228                                     "Unknown FCP Response Code 0x%x", code);
3229                                 ptr = lb;
3230                         } else {
3231                                 ptr = rnames[code];
3232                         }
3233                         isp_xs_prt(isp, xs, ISP_LOGWARN,
3234                             "FCP RESPONSE, LENGTH %u: %s CDB0=0x%02x",
3235                             rlen, ptr, XS_CDBP(xs)[0] & 0xff);
3236                         if (code != FCP_RSPNS_TMF_DONE &&
3237                             code != FCP_RSPNS_TMF_SUCCEEDED)
3238                                 XS_SETERR(xs, HBA_BOTCH);
3239                 }
3240                 isp_parse_status_24xx(isp, sp, xs);
3241                 if (slen > 0) {
3242                         XS_SAVE_SENSE(xs, snsp, slen);
3243                         if (totslen > slen) {
3244                                 cont = totslen - slen;
3245                                 cont_xs = xs;
3246                                 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
3247                                     "Expecting Status Continuations for %u bytes",
3248                                     cont);
3249                         }
3250                 }
3251
3252                 ISP_DMAFREE(isp, xs);
3253                 isp_destroy_handle(isp, sp->req_handle);
3254                 ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
3255
3256                 /* Complete command if we expect no Status Continuations. */
3257                 if (cont == 0)
3258                         isp_done(xs);
3259         }
3260
3261         /* We haven't received all Status Continuations, but that is it. */
3262         if (cont > 0)
3263                 isp_done(cont_xs);
3264
3265         /* If we processed any IOCBs, let ISP know about it. */
3266         if (optr != isp->isp_resodx) {
3267                 ISP_WRITE(isp, BIU2400_RSPOUTP, optr);
3268                 isp->isp_resodx = optr;
3269         }
3270 }
3271
3272
3273 void
3274 isp_intr_async(ispsoftc_t *isp, uint16_t mbox)
3275 {
3276         fcparam *fcp;
3277         uint16_t chan;
3278
3279         isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
3280
3281         switch (mbox) {
3282         case ASYNC_SYSTEM_ERROR:
3283                 isp->isp_state = ISP_CRASHED;
3284                 for (chan = 0; chan < isp->isp_nchan; chan++) {
3285                         FCPARAM(isp, chan)->isp_loopstate = LOOP_NIL;
3286                         isp_change_fw_state(isp, chan, FW_CONFIG_WAIT);
3287                 }
3288                 /*
3289                  * Were we waiting for a mailbox command to complete?
3290                  * If so, it's dead, so wake up the waiter.
3291                  */
3292                 if (isp->isp_mboxbsy) {
3293                         isp->isp_obits = 1;
3294                         isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
3295                         isp->isp_mboxbsy = 0;
3296                 }
3297                 /*
3298                  * It's up to the handler for isp_async to reinit stuff and
3299                  * restart the firmware
3300                  */
3301                 isp_async(isp, ISPASYNC_FW_CRASH);
3302                 break;
3303
3304         case ASYNC_RQS_XFER_ERR:
3305                 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
3306                 break;
3307
3308         case ASYNC_RSP_XFER_ERR:
3309                 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
3310                 break;
3311
3312         case ASYNC_ATIO_XFER_ERR:
3313                 isp_prt(isp, ISP_LOGERR, "ATIO Queue Transfer Error");
3314                 break;
3315
3316         case ASYNC_LIP_OCCURRED:
3317         case ASYNC_LIP_NOS_OLS_RECV:
3318         case ASYNC_LIP_ERROR:
3319         case ASYNC_PTPMODE:
3320                 /*
3321                  * These are broadcast events that have to be sent across
3322                  * all active channels.
3323                  */
3324                 for (chan = 0; chan < isp->isp_nchan; chan++) {
3325                         fcp = FCPARAM(isp, chan);
3326                         int topo = fcp->isp_topo;
3327
3328                         if (fcp->role == ISP_ROLE_NONE)
3329                                 continue;
3330                         if (fcp->isp_loopstate > LOOP_HAVE_LINK)
3331                                 fcp->isp_loopstate = LOOP_HAVE_LINK;
3332                         ISP_SET_SENDMARKER(isp, chan, 1);
3333                         isp_async(isp, ISPASYNC_LIP, chan);
3334 #ifdef  ISP_TARGET_MODE
3335                         isp_target_async(isp, chan, mbox);
3336 #endif
3337                         /*
3338                          * We've had problems with data corruption occurring on
3339                          * commands that complete (with no apparent error) after
3340                          * we receive a LIP. This has been observed mostly on
3341                          * Local Loop topologies. To be safe, let's just mark
3342                          * all active initiator commands as dead.
3343                          */
3344                         if (topo == TOPO_NL_PORT || topo == TOPO_FL_PORT) {
3345                                 int i, j;
3346                                 for (i = j = 0; i < ISP_HANDLE_NUM(isp); i++) {
3347                                         XS_T *xs;
3348                                         isp_hdl_t *hdp;
3349
3350                                         hdp = &isp->isp_xflist[i];
3351                                         if (ISP_H2HT(hdp->handle) != ISP_HANDLE_INITIATOR) {
3352                                                 continue;
3353                                         }
3354                                         xs = hdp->cmd;
3355                                         if (XS_CHANNEL(xs) != chan) {
3356                                                 continue;
3357                                         }
3358                                         j++;
3359                                         isp_prt(isp, ISP_LOG_WARN1,
3360                                             "%d.%d.%jx bus reset set at %s:%u",
3361                                             XS_CHANNEL(xs), XS_TGT(xs),
3362                                             (uintmax_t)XS_LUN(xs),
3363                                             __func__, __LINE__);
3364                                         XS_SETERR(xs, HBA_BUSRESET);
3365                                 }
3366                                 if (j) {
3367                                         isp_prt(isp, ISP_LOGERR, lipd, chan, j);
3368                                 }
3369                         }
3370                 }
3371                 break;
3372
3373         case ASYNC_LOOP_UP:
3374                 /*
3375                  * This is a broadcast event that has to be sent across
3376                  * all active channels.
3377                  */
3378                 for (chan = 0; chan < isp->isp_nchan; chan++) {
3379                         fcp = FCPARAM(isp, chan);
3380                         if (fcp->role == ISP_ROLE_NONE)
3381                                 continue;
3382                         fcp->isp_linkstate = 1;
3383                         if (fcp->isp_loopstate < LOOP_HAVE_LINK)
3384                                 fcp->isp_loopstate = LOOP_HAVE_LINK;
3385                         ISP_SET_SENDMARKER(isp, chan, 1);
3386                         isp_async(isp, ISPASYNC_LOOP_UP, chan);
3387 #ifdef  ISP_TARGET_MODE
3388                         isp_target_async(isp, chan, mbox);
3389 #endif
3390                 }
3391                 break;
3392
3393         case ASYNC_LOOP_DOWN:
3394                 /*
3395                  * This is a broadcast event that has to be sent across
3396                  * all active channels.
3397                  */
3398                 for (chan = 0; chan < isp->isp_nchan; chan++) {
3399                         fcp = FCPARAM(isp, chan);
3400                         if (fcp->role == ISP_ROLE_NONE)
3401                                 continue;
3402                         ISP_SET_SENDMARKER(isp, chan, 1);
3403                         fcp->isp_linkstate = 0;
3404                         fcp->isp_loopstate = LOOP_NIL;
3405                         isp_async(isp, ISPASYNC_LOOP_DOWN, chan);
3406 #ifdef  ISP_TARGET_MODE
3407                         isp_target_async(isp, chan, mbox);
3408 #endif
3409                 }
3410                 break;
3411
3412         case ASYNC_LOOP_RESET:
3413                 /*
3414                  * This is a broadcast event that has to be sent across
3415                  * all active channels.
3416                  */
3417                 for (chan = 0; chan < isp->isp_nchan; chan++) {
3418                         fcp = FCPARAM(isp, chan);
3419                         if (fcp->role == ISP_ROLE_NONE)
3420                                 continue;
3421                         ISP_SET_SENDMARKER(isp, chan, 1);
3422                         if (fcp->isp_loopstate > LOOP_HAVE_LINK)
3423                                 fcp->isp_loopstate = LOOP_HAVE_LINK;
3424                         isp_async(isp, ISPASYNC_LOOP_RESET, chan);
3425 #ifdef  ISP_TARGET_MODE
3426                         isp_target_async(isp, chan, mbox);
3427 #endif
3428                 }
3429                 break;
3430
3431         case ASYNC_PDB_CHANGED:
3432         {
3433                 int echan, nphdl, nlstate, reason;
3434
3435                 nphdl = ISP_READ(isp, OUTMAILBOX1);
3436                 nlstate = ISP_READ(isp, OUTMAILBOX2);
3437                 reason = ISP_READ(isp, OUTMAILBOX3) >> 8;
3438                 if (ISP_CAP_MULTI_ID(isp)) {
3439                         chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
3440                         if (chan == 0xff || nphdl == NIL_HANDLE) {
3441                                 chan = 0;
3442                                 echan = isp->isp_nchan - 1;
3443                         } else if (chan >= isp->isp_nchan) {
3444                                 break;
3445                         } else {
3446                                 echan = chan;
3447                         }
3448                 } else {
3449                         chan = echan = 0;
3450                 }
3451                 for (; chan <= echan; chan++) {
3452                         fcp = FCPARAM(isp, chan);
3453                         if (fcp->role == ISP_ROLE_NONE)
3454                                 continue;
3455                         if (fcp->isp_loopstate > LOOP_LTEST_DONE) {
3456                                 if (nphdl != NIL_HANDLE &&
3457                                     nphdl == fcp->isp_login_hdl &&
3458                                     reason == PDB24XX_AE_OPN_2)
3459                                         continue;
3460                                 fcp->isp_loopstate = LOOP_LTEST_DONE;
3461                         } else if (fcp->isp_loopstate < LOOP_HAVE_LINK)
3462                                 fcp->isp_loopstate = LOOP_HAVE_LINK;
3463                         isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
3464                             ISPASYNC_CHANGE_PDB, nphdl, nlstate, reason);
3465                 }
3466                 break;
3467         }
3468         case ASYNC_CHANGE_NOTIFY:
3469         {
3470                 int portid;
3471
3472                 portid = ((ISP_READ(isp, OUTMAILBOX1) & 0xff) << 16) |
3473                     ISP_READ(isp, OUTMAILBOX2);
3474                 if (ISP_CAP_MULTI_ID(isp)) {
3475                         chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
3476                         if (chan >= isp->isp_nchan)
3477                                 break;
3478                 } else {
3479                         chan = 0;
3480                 }
3481                 fcp = FCPARAM(isp, chan);
3482                 if (fcp->role == ISP_ROLE_NONE)
3483                         break;
3484                 if (fcp->isp_loopstate > LOOP_LTEST_DONE)
3485                         fcp->isp_loopstate = LOOP_LTEST_DONE;
3486                 else if (fcp->isp_loopstate < LOOP_HAVE_LINK)
3487                         fcp->isp_loopstate = LOOP_HAVE_LINK;
3488                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
3489                     ISPASYNC_CHANGE_SNS, portid);
3490                 break;
3491         }
3492         case ASYNC_ERR_LOGGING_DISABLED:
3493                 isp_prt(isp, ISP_LOGWARN, "Error logging disabled (reason 0x%x)",
3494                     ISP_READ(isp, OUTMAILBOX1));
3495                 break;
3496         case ASYNC_P2P_INIT_ERR:
3497                 isp_prt(isp, ISP_LOGWARN, "P2P init error (reason 0x%x)",
3498                     ISP_READ(isp, OUTMAILBOX1));
3499                 break;
3500         case ASYNC_RCV_ERR:
3501                 isp_prt(isp, ISP_LOGWARN, "Receive Error");
3502                 break;
3503         case ASYNC_RJT_SENT:    /* same as ASYNC_QFULL_SENT */
3504                 isp_prt(isp, ISP_LOGTDEBUG0, "LS_RJT sent");
3505                 break;
3506         case ASYNC_FW_RESTART_COMPLETE:
3507                 isp_prt(isp, ISP_LOGDEBUG0, "FW restart complete");
3508                 break;
3509         case ASYNC_TEMPERATURE_ALERT:
3510                 isp_prt(isp, ISP_LOGERR, "Temperature alert (subcode 0x%x)",
3511                     ISP_READ(isp, OUTMAILBOX1));
3512                 break;
3513         case ASYNC_INTER_DRIVER_COMP:
3514                 isp_prt(isp, ISP_LOGDEBUG0, "Inter-driver communication complete");
3515                 break;
3516         case ASYNC_INTER_DRIVER_NOTIFY:
3517                 isp_prt(isp, ISP_LOGDEBUG0, "Inter-driver communication notification");
3518                 break;
3519         case ASYNC_INTER_DRIVER_TIME_EXT:
3520                 isp_prt(isp, ISP_LOGDEBUG0, "Inter-driver communication time extended");
3521                 break;
3522         case ASYNC_TRANSCEIVER_INSERTION:
3523                 isp_prt(isp, ISP_LOGDEBUG0, "Transceiver insertion (0x%x)",
3524                     ISP_READ(isp, OUTMAILBOX1));
3525                 break;
3526         case ASYNC_TRANSCEIVER_REMOVAL:
3527                 isp_prt(isp, ISP_LOGDEBUG0, "Transceiver removal");
3528                 break;
3529         case ASYNC_NIC_FW_STATE_CHANGE:
3530                 isp_prt(isp, ISP_LOGDEBUG0, "NIC Firmware State Change");
3531                 break;
3532         case ASYNC_AUTOLOAD_FW_COMPLETE:
3533                 isp_prt(isp, ISP_LOGDEBUG0, "Autoload FW init complete");
3534                 break;
3535         case ASYNC_AUTOLOAD_FW_FAILURE:
3536                 isp_prt(isp, ISP_LOGERR, "Autoload FW init failure");
3537                 break;
3538         default:
3539                 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
3540                 break;
3541         }
3542 }
3543
3544 /*
3545  * Handle completions with control handles by waking up waiting threads.
3546  */
3547 static int
3548 isp_handle_control(ispsoftc_t *isp, isphdr_t *hp)
3549 {
3550         uint32_t hdl;
3551         void *ptr;
3552
3553         switch (hp->rqs_entry_type) {
3554         case RQSTYPE_RESPONSE:
3555         case RQSTYPE_MARKER:
3556         case RQSTYPE_NOTIFY_ACK:
3557         case RQSTYPE_CTIO7:
3558         case RQSTYPE_TSK_MGMT:
3559         case RQSTYPE_CT_PASSTHRU:
3560         case RQSTYPE_VP_MODIFY:
3561         case RQSTYPE_VP_CTRL:
3562         case RQSTYPE_ABORT_IO:
3563         case RQSTYPE_MBOX:
3564         case RQSTYPE_LOGIN:
3565         case RQSTYPE_ELS_PASSTHRU:
3566                 ISP_IOXGET_32(isp, (uint32_t *)(hp + 1), hdl);
3567                 if (ISP_H2HT(hdl) != ISP_HANDLE_CTRL)
3568                         break;
3569                 ptr = isp_find_xs(isp, hdl);
3570                 if (ptr != NULL) {
3571                         isp_destroy_handle(isp, hdl);
3572                         memcpy(ptr, hp, QENTRY_LEN);
3573                         wakeup(ptr);
3574                 }
3575                 return (1);
3576         }
3577         return (0);
3578 }
3579
3580 static void
3581 isp_handle_rpt_id_acq(ispsoftc_t *isp, isphdr_t *hp)
3582 {
3583         fcparam *fcp;
3584         isp_ridacq_t rid;
3585         int chan, c;
3586         uint32_t portid;
3587
3588         isp_get_ridacq(isp, (isp_ridacq_t *)hp, &rid);
3589         portid = (uint32_t)rid.ridacq_vp_port_hi << 16 |
3590             rid.ridacq_vp_port_lo;
3591         if (rid.ridacq_format == 0) {
3592                 for (chan = 0; chan < isp->isp_nchan; chan++) {
3593                         fcp = FCPARAM(isp, chan);
3594                         if (fcp->role == ISP_ROLE_NONE)
3595                                 continue;
3596                         c = (chan == 0) ? 127 : (chan - 1);
3597                         if (rid.ridacq_map[c / 16] & (1 << (c % 16)) ||
3598                             chan == 0) {
3599                                 fcp->isp_loopstate = LOOP_HAVE_LINK;
3600                                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
3601                                     chan, ISPASYNC_CHANGE_OTHER);
3602                         } else {
3603                                 fcp->isp_loopstate = LOOP_NIL;
3604                                 isp_async(isp, ISPASYNC_LOOP_DOWN,
3605                                     chan);
3606                         }
3607                 }
3608         } else {
3609                 fcp = FCPARAM(isp, rid.ridacq_vp_index);
3610                 if (rid.ridacq_vp_status == RIDACQ_STS_COMPLETE ||
3611                     rid.ridacq_vp_status == RIDACQ_STS_CHANGED) {
3612                         fcp->isp_topo = (rid.ridacq_map[0] >> 9) & 0x7;
3613                         fcp->isp_portid = portid;
3614                         fcp->isp_loopstate = LOOP_HAVE_ADDR;
3615                         isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
3616                             rid.ridacq_vp_index, ISPASYNC_CHANGE_OTHER);
3617                 } else {
3618                         fcp->isp_loopstate = LOOP_NIL;
3619                         isp_async(isp, ISPASYNC_LOOP_DOWN,
3620                             rid.ridacq_vp_index);
3621                 }
3622         }
3623 }
3624
3625 static void
3626 isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp, XS_T *xs)
3627 {
3628         int ru_marked, sv_marked;
3629         int chan = XS_CHANNEL(xs);
3630
3631         switch (sp->req_completion_status) {
3632         case RQCS_COMPLETE:
3633                 return;
3634
3635         case RQCS_DMA_ERROR:
3636                 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA error");
3637                 if (XS_NOERR(xs))
3638                         XS_SETERR(xs, HBA_BOTCH);
3639                 break;
3640
3641         case RQCS_TRANSPORT_ERROR:
3642                 isp_xs_prt(isp, xs,  ISP_LOGERR, "Transport Error");
3643                 if (XS_NOERR(xs))
3644                         XS_SETERR(xs, HBA_BOTCH);
3645                 break;
3646
3647         case RQCS_RESET_OCCURRED:
3648                 isp_xs_prt(isp, xs, ISP_LOGWARN, "reset destroyed command");
3649                 FCPARAM(isp, chan)->sendmarker = 1;
3650                 if (XS_NOERR(xs))
3651                         XS_SETERR(xs, HBA_BUSRESET);
3652                 return;
3653
3654         case RQCS_ABORTED:
3655                 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
3656                 FCPARAM(isp, chan)->sendmarker = 1;
3657                 if (XS_NOERR(xs))
3658                         XS_SETERR(xs, HBA_ABORTED);
3659                 return;
3660
3661         case RQCS_TIMEOUT:
3662                 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command Timed Out");
3663                 if (XS_NOERR(xs))
3664                         XS_SETERR(xs, HBA_CMDTIMEOUT);
3665                 return;
3666
3667         case RQCS_DATA_OVERRUN:
3668                 XS_SET_RESID(xs, sp->req_resid);
3669                 isp_xs_prt(isp, xs, ISP_LOGERR, "Data Overrun");
3670                 if (XS_NOERR(xs))
3671                         XS_SETERR(xs, HBA_DATAOVR);
3672                 return;
3673
3674         case RQCS_DRE:          /* data reassembly error */
3675                 isp_prt(isp, ISP_LOGERR, "Chan %d data reassembly error for target %d", chan, XS_TGT(xs));
3676                 if (XS_NOERR(xs))
3677                         XS_SETERR(xs, HBA_BOTCH);
3678                 return;
3679
3680         case RQCS_TABORT:       /* aborted by target */
3681                 isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS", chan, XS_TGT(xs));
3682                 if (XS_NOERR(xs))
3683                         XS_SETERR(xs, HBA_ABORTED);
3684                 return;
3685
3686         case RQCS_DATA_UNDERRUN:
3687                 ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
3688                 /*
3689                  * We can get an underrun w/o things being marked
3690                  * if we got a non-zero status.
3691                  */
3692                 sv_marked = (sp->req_scsi_status & (RQCS_SV|RQCS_RV)) != 0;
3693                 if ((ru_marked == 0 && sv_marked == 0) ||
3694                     (sp->req_resid > XS_XFRLEN(xs))) {
3695                         isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
3696                         if (XS_NOERR(xs))
3697                                 XS_SETERR(xs, HBA_BOTCH);
3698                         return;
3699                 }
3700                 XS_SET_RESID(xs, sp->req_resid);
3701                 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
3702                 return;
3703
3704         case RQCS_PORT_UNAVAILABLE:
3705                 /*
3706                  * No such port on the loop. Moral equivalent of SELTIMEO
3707                  */
3708         case RQCS_PORT_LOGGED_OUT:
3709         {
3710                 const char *reason;
3711                 uint8_t sts = sp->req_completion_status & 0xff;
3712                 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
3713                 fcportdb_t *lp;
3714
3715                 /*
3716                  * It was there (maybe)- treat as a selection timeout.
3717                  */
3718                 if (sts == RQCS_PORT_UNAVAILABLE) {
3719                         reason = "unavailable";
3720                 } else {
3721                         reason = "logout";
3722                 }
3723
3724                 isp_prt(isp, ISP_LOGINFO, "Chan %d port %s for target %d",
3725                     chan, reason, XS_TGT(xs));
3726
3727                 /* XXX: Should we trigger rescan or FW announce change? */
3728
3729                 if (XS_NOERR(xs)) {
3730                         lp = &fcp->portdb[XS_TGT(xs)];
3731                         if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
3732                                 *XS_STSP(xs) = SCSI_BUSY;
3733                                 XS_SETERR(xs, HBA_TGTBSY);
3734                         } else
3735                                 XS_SETERR(xs, HBA_SELTIMEOUT);
3736                 }
3737                 return;
3738         }
3739         case RQCS_PORT_CHANGED:
3740                 isp_prt(isp, ISP_LOGWARN, "port changed for target %d chan %d", XS_TGT(xs), chan);
3741                 if (XS_NOERR(xs)) {
3742                         *XS_STSP(xs) = SCSI_BUSY;
3743                         XS_SETERR(xs, HBA_TGTBSY);
3744                 }
3745                 return;
3746
3747         case RQCS_ENOMEM:       /* f/w resource unavailable */
3748                 isp_prt(isp, ISP_LOGWARN, "f/w resource unavailable for target %d chan %d", XS_TGT(xs), chan);
3749                 if (XS_NOERR(xs)) {
3750                         *XS_STSP(xs) = SCSI_BUSY;
3751                         XS_SETERR(xs, HBA_TGTBSY);
3752                 }
3753                 return;
3754
3755         case RQCS_TMO:          /* task management overrun */
3756                 isp_prt(isp, ISP_LOGWARN, "command for target %d overlapped task management for chan %d", XS_TGT(xs), chan);
3757                 if (XS_NOERR(xs)) {
3758                         *XS_STSP(xs) = SCSI_BUSY;
3759                         XS_SETERR(xs, HBA_TGTBSY);
3760                 }
3761                 return;
3762
3763         default:
3764                 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x on chan %d", sp->req_completion_status, chan);
3765                 break;
3766         }
3767         if (XS_NOERR(xs))
3768                 XS_SETERR(xs, HBA_BOTCH);
3769 }
3770
3771 #define ISP_FC_IBITS(op)        ((mbpfc[((op)<<3) + 0] << 24) | (mbpfc[((op)<<3) + 1] << 16) | (mbpfc[((op)<<3) + 2] << 8) | (mbpfc[((op)<<3) + 3]))
3772 #define ISP_FC_OBITS(op)        ((mbpfc[((op)<<3) + 4] << 24) | (mbpfc[((op)<<3) + 5] << 16) | (mbpfc[((op)<<3) + 6] << 8) | (mbpfc[((op)<<3) + 7]))
3773
3774 #define ISP_FC_OPMAP(in0, out0)                                                   0,   0,   0, in0,    0,    0,    0, out0
3775 #define ISP_FC_OPMAP_HALF(in1, in0, out1, out0)                                   0,   0, in1, in0,    0,    0, out1, out0
3776 #define ISP_FC_OPMAP_FULL(in3, in2, in1, in0, out3, out2, out1, out0)           in3, in2, in1, in0, out3, out2, out1, out0
3777 static const uint32_t mbpfc[] = {
3778         ISP_FC_OPMAP(0x01, 0x01),       /* 0x00: MBOX_NO_OP */
3779         ISP_FC_OPMAP(0x1f, 0x01),       /* 0x01: MBOX_LOAD_RAM */
3780         ISP_FC_OPMAP_HALF(0x07, 0xff, 0x00, 0x1f),      /* 0x02: MBOX_EXEC_FIRMWARE */
3781         ISP_FC_OPMAP(0xdf, 0x01),       /* 0x03: MBOX_DUMP_RAM */
3782         ISP_FC_OPMAP(0x07, 0x07),       /* 0x04: MBOX_WRITE_RAM_WORD */
3783         ISP_FC_OPMAP(0x03, 0x07),       /* 0x05: MBOX_READ_RAM_WORD */
3784         ISP_FC_OPMAP_FULL(0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff),      /* 0x06: MBOX_MAILBOX_REG_TEST */
3785         ISP_FC_OPMAP(0x07, 0x07),       /* 0x07: MBOX_VERIFY_CHECKSUM   */
3786         ISP_FC_OPMAP_FULL(0x0, 0x0, 0x0, 0x01, 0x0, 0x3, 0x80, 0x7f),   /* 0x08: MBOX_ABOUT_FIRMWARE */
3787         ISP_FC_OPMAP(0xdf, 0x01),       /* 0x09: MBOX_LOAD_RISC_RAM_2100 */
3788         ISP_FC_OPMAP(0xdf, 0x01),       /* 0x0a: DUMP RAM */
3789         ISP_FC_OPMAP_HALF(0x1, 0xff, 0x0, 0x01),        /* 0x0b: MBOX_LOAD_RISC_RAM */
3790         ISP_FC_OPMAP(0x00, 0x00),       /* 0x0c: */
3791         ISP_FC_OPMAP_HALF(0x1, 0x0f, 0x0, 0x01),        /* 0x0d: MBOX_WRITE_RAM_WORD_EXTENDED */
3792         ISP_FC_OPMAP(0x01, 0x05),       /* 0x0e: MBOX_CHECK_FIRMWARE */
3793         ISP_FC_OPMAP_HALF(0x1, 0x03, 0x0, 0x0d),        /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED */
3794         ISP_FC_OPMAP(0x1f, 0x11),       /* 0x10: MBOX_INIT_REQ_QUEUE */
3795         ISP_FC_OPMAP(0x2f, 0x21),       /* 0x11: MBOX_INIT_RES_QUEUE */
3796         ISP_FC_OPMAP(0x0f, 0x01),       /* 0x12: MBOX_EXECUTE_IOCB */
3797         ISP_FC_OPMAP(0x03, 0x03),       /* 0x13: MBOX_WAKE_UP   */
3798         ISP_FC_OPMAP_HALF(0x1, 0xff, 0x0, 0x03),        /* 0x14: MBOX_STOP_FIRMWARE */
3799         ISP_FC_OPMAP(0x4f, 0x01),       /* 0x15: MBOX_ABORT */
3800         ISP_FC_OPMAP(0x07, 0x01),       /* 0x16: MBOX_ABORT_DEVICE */
3801         ISP_FC_OPMAP(0x07, 0x01),       /* 0x17: MBOX_ABORT_TARGET */
3802         ISP_FC_OPMAP(0x03, 0x03),       /* 0x18: MBOX_BUS_RESET */
3803         ISP_FC_OPMAP(0x07, 0x05),       /* 0x19: MBOX_STOP_QUEUE */
3804         ISP_FC_OPMAP(0x07, 0x05),       /* 0x1a: MBOX_START_QUEUE */
3805         ISP_FC_OPMAP(0x07, 0x05),       /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
3806         ISP_FC_OPMAP(0x07, 0x05),       /* 0x1c: MBOX_ABORT_QUEUE */
3807         ISP_FC_OPMAP(0x07, 0x03),       /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
3808         ISP_FC_OPMAP(0x00, 0x00),       /* 0x1e: */
3809         ISP_FC_OPMAP(0x01, 0x07),       /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
3810         ISP_FC_OPMAP_HALF(0x2, 0x01, 0x7e, 0xcf),       /* 0x20: MBOX_GET_LOOP_ID */
3811         ISP_FC_OPMAP(0x00, 0x00),       /* 0x21: */
3812         ISP_FC_OPMAP(0x03, 0x4b),       /* 0x22: MBOX_GET_TIMEOUT_PARAMS */
3813         ISP_FC_OPMAP(0x00, 0x00),       /* 0x23: */
3814         ISP_FC_OPMAP(0x00, 0x00),       /* 0x24: */
3815         ISP_FC_OPMAP(0x00, 0x00),       /* 0x25: */
3816         ISP_FC_OPMAP(0x00, 0x00),       /* 0x26: */
3817         ISP_FC_OPMAP(0x00, 0x00),       /* 0x27: */
3818         ISP_FC_OPMAP(0x01, 0x03),       /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */
3819         ISP_FC_OPMAP(0x03, 0x07),       /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */
3820         ISP_FC_OPMAP(0x00, 0x00),       /* 0x2a: */
3821         ISP_FC_OPMAP(0x00, 0x00),       /* 0x2b: */
3822         ISP_FC_OPMAP(0x00, 0x00),       /* 0x2c: */
3823         ISP_FC_OPMAP(0x00, 0x00),       /* 0x2d: */
3824         ISP_FC_OPMAP(0x00, 0x00),       /* 0x2e: */
3825         ISP_FC_OPMAP(0x00, 0x00),       /* 0x2f: */
3826         ISP_FC_OPMAP(0x00, 0x00),       /* 0x30: */
3827         ISP_FC_OPMAP(0x00, 0x00),       /* 0x31: */
3828         ISP_FC_OPMAP(0x4b, 0x4b),       /* 0x32: MBOX_SET_TIMEOUT_PARAMS */
3829         ISP_FC_OPMAP(0x00, 0x00),       /* 0x33: */
3830         ISP_FC_OPMAP(0x00, 0x00),       /* 0x34: */
3831         ISP_FC_OPMAP(0x00, 0x00),       /* 0x35: */
3832         ISP_FC_OPMAP(0x00, 0x00),       /* 0x36: */
3833         ISP_FC_OPMAP(0x00, 0x00),       /* 0x37: */
3834         ISP_FC_OPMAP(0x0f, 0x01),       /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */
3835         ISP_FC_OPMAP(0x0f, 0x07),       /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */
3836         ISP_FC_OPMAP(0x00, 0x00),       /* 0x3a: */
3837         ISP_FC_OPMAP(0x00, 0x00),       /* 0x3b: */
3838         ISP_FC_OPMAP(0x00, 0x00),       /* 0x3c: */
3839         ISP_FC_OPMAP(0x00, 0x00),       /* 0x3d: */
3840         ISP_FC_OPMAP(0x00, 0x00),       /* 0x3e: */
3841         ISP_FC_OPMAP(0x00, 0x00),       /* 0x3f: */
3842         ISP_FC_OPMAP(0x03, 0x01),       /* 0x40: MBOX_LOOP_PORT_BYPASS */
3843         ISP_FC_OPMAP(0x03, 0x01),       /* 0x41: MBOX_LOOP_PORT_ENABLE */
3844         ISP_FC_OPMAP_HALF(0x0, 0x01, 0x1f, 0xcf),       /* 0x42: MBOX_GET_RESOURCE_COUNT */
3845         ISP_FC_OPMAP(0x01, 0x01),       /* 0x43: MBOX_REQUEST_OFFLINE_MODE */
3846         ISP_FC_OPMAP(0x00, 0x00),       /* 0x44: */
3847         ISP_FC_OPMAP(0x00, 0x00),       /* 0x45: */
3848         ISP_FC_OPMAP(0x00, 0x00),       /* 0x46: */
3849         ISP_FC_OPMAP(0xcf, 0x03),       /* 0x47: GET PORT_DATABASE ENHANCED */
3850         ISP_FC_OPMAP(0xcf, 0x0f),       /* 0x48: MBOX_INIT_FIRMWARE_MULTI_ID */
3851         ISP_FC_OPMAP(0xcd, 0x01),       /* 0x49: MBOX_GET_VP_DATABASE */
3852         ISP_FC_OPMAP_HALF(0x2, 0xcd, 0x0, 0x01),        /* 0x4a: MBOX_GET_VP_DATABASE_ENTRY */
3853         ISP_FC_OPMAP(0x00, 0x00),       /* 0x4b: */
3854         ISP_FC_OPMAP(0x00, 0x00),       /* 0x4c: */
3855         ISP_FC_OPMAP(0x00, 0x00),       /* 0x4d: */
3856         ISP_FC_OPMAP(0x00, 0x00),       /* 0x4e: */
3857         ISP_FC_OPMAP(0x00, 0x00),       /* 0x4f: */
3858         ISP_FC_OPMAP(0x00, 0x00),       /* 0x50: */
3859         ISP_FC_OPMAP(0x00, 0x00),       /* 0x51: */
3860         ISP_FC_OPMAP(0x00, 0x00),       /* 0x52: */
3861         ISP_FC_OPMAP(0x00, 0x00),       /* 0x53: */
3862         ISP_FC_OPMAP(0xcf, 0x01),       /* 0x54: EXECUTE IOCB A64 */
3863         ISP_FC_OPMAP(0x00, 0x00),       /* 0x55: */
3864         ISP_FC_OPMAP(0x00, 0x00),       /* 0x56: */
3865         ISP_FC_OPMAP(0x00, 0x00),       /* 0x57: */
3866         ISP_FC_OPMAP(0x00, 0x00),       /* 0x58: */
3867         ISP_FC_OPMAP(0x00, 0x00),       /* 0x59: */
3868         ISP_FC_OPMAP(0x00, 0x00),       /* 0x5a: */
3869         ISP_FC_OPMAP(0x03, 0x01),       /* 0x5b: MBOX_DRIVER_HEARTBEAT */
3870         ISP_FC_OPMAP(0xcf, 0x01),       /* 0x5c: MBOX_FW_HEARTBEAT */
3871         ISP_FC_OPMAP(0x07, 0x1f),       /* 0x5d: MBOX_GET_SET_DATA_RATE */
3872         ISP_FC_OPMAP(0x00, 0x00),       /* 0x5e: */
3873         ISP_FC_OPMAP(0x00, 0x00),       /* 0x5f: */
3874         ISP_FC_OPMAP(0xcf, 0x0f),       /* 0x60: MBOX_INIT_FIRMWARE */
3875         ISP_FC_OPMAP(0x00, 0x00),       /* 0x61: */
3876         ISP_FC_OPMAP(0x01, 0x01),       /* 0x62: MBOX_INIT_LIP */
3877         ISP_FC_OPMAP(0xcd, 0x03),       /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
3878         ISP_FC_OPMAP(0xcf, 0x01),       /* 0x64: MBOX_GET_PORT_DB */
3879         ISP_FC_OPMAP(0x07, 0x01),       /* 0x65: MBOX_CLEAR_ACA */
3880         ISP_FC_OPMAP(0x07, 0x01),       /* 0x66: MBOX_TARGET_RESET */
3881         ISP_FC_OPMAP(0x07, 0x01),       /* 0x67: MBOX_CLEAR_TASK_SET */
3882         ISP_FC_OPMAP(0x07, 0x01),       /* 0x68: MBOX_ABORT_TASK_SET */
3883         ISP_FC_OPMAP_HALF(0x00, 0x01, 0x0f, 0x1f),      /* 0x69: MBOX_GET_FW_STATE */
3884         ISP_FC_OPMAP_HALF(0x6, 0x03, 0x0, 0xcf),        /* 0x6a: MBOX_GET_PORT_NAME */
3885         ISP_FC_OPMAP(0xcf, 0x01),       /* 0x6b: MBOX_GET_LINK_STATUS */
3886         ISP_FC_OPMAP(0x0f, 0x01),       /* 0x6c: MBOX_INIT_LIP_RESET */
3887         ISP_FC_OPMAP(0x00, 0x00),       /* 0x6d: */
3888         ISP_FC_OPMAP(0xcf, 0x03),       /* 0x6e: MBOX_SEND_SNS */
3889         ISP_FC_OPMAP(0x0f, 0x07),       /* 0x6f: MBOX_FABRIC_LOGIN */
3890         ISP_FC_OPMAP_HALF(0x02, 0x03, 0x00, 0x03),      /* 0x70: MBOX_SEND_CHANGE_REQUEST */
3891         ISP_FC_OPMAP(0x03, 0x03),       /* 0x71: MBOX_FABRIC_LOGOUT */
3892         ISP_FC_OPMAP(0x0f, 0x0f),       /* 0x72: MBOX_INIT_LIP_LOGIN */
3893         ISP_FC_OPMAP(0x00, 0x00),       /* 0x73: */
3894         ISP_FC_OPMAP(0x07, 0x01),       /* 0x74: LOGIN LOOP PORT */
3895         ISP_FC_OPMAP_HALF(0x03, 0xcf, 0x00, 0x07),      /* 0x75: GET PORT/NODE NAME LIST */
3896         ISP_FC_OPMAP(0x4f, 0x01),       /* 0x76: SET VENDOR ID */
3897         ISP_FC_OPMAP(0xcd, 0x01),       /* 0x77: INITIALIZE IP MAILBOX */
3898         ISP_FC_OPMAP(0x00, 0x00),       /* 0x78: */
3899         ISP_FC_OPMAP(0x00, 0x00),       /* 0x79: */
3900         ISP_FC_OPMAP(0x00, 0x00),       /* 0x7a: */
3901         ISP_FC_OPMAP(0x00, 0x00),       /* 0x7b: */
3902         ISP_FC_OPMAP_HALF(0x03, 0x4f, 0x00, 0x07),      /* 0x7c: Get ID List */
3903         ISP_FC_OPMAP(0xcf, 0x01),       /* 0x7d: SEND LFA */
3904         ISP_FC_OPMAP(0x0f, 0x01)        /* 0x7e: LUN RESET */
3905 };
3906 #define MAX_FC_OPCODE   0x7e
3907 /*
3908  * Footnotes
3909  *
3910  * (1): this sets bits 21..16 in mailbox register #8, which we nominally
3911  *      do not access at this time in the core driver. The caller is
3912  *      responsible for setting this register first (Gross!). The assumption
3913  *      is that we won't overflow.
3914  */
3915
3916 static const char *fc_mbcmd_names[] = {
3917         "NO-OP",                        /* 00h */
3918         "LOAD RAM",
3919         "EXEC FIRMWARE",
3920         "DUMP RAM",
3921         "WRITE RAM WORD",
3922         "READ RAM WORD",
3923         "MAILBOX REG TEST",
3924         "VERIFY CHECKSUM",
3925         "ABOUT FIRMWARE",
3926         "LOAD RAM (2100)",
3927         "DUMP RAM",
3928         "LOAD RISC RAM",
3929         "DUMP RISC RAM",
3930         "WRITE RAM WORD EXTENDED",
3931         "CHECK FIRMWARE",
3932         "READ RAM WORD EXTENDED",
3933         "INIT REQUEST QUEUE",           /* 10h */
3934         "INIT RESULT QUEUE",
3935         "EXECUTE IOCB",
3936         "WAKE UP",
3937         "STOP FIRMWARE",
3938         "ABORT",
3939         "ABORT DEVICE",
3940         "ABORT TARGET",
3941         "BUS RESET",
3942         "STOP QUEUE",
3943         "START QUEUE",
3944         "SINGLE STEP QUEUE",
3945         "ABORT QUEUE",
3946         "GET DEV QUEUE STATUS",
3947         NULL,
3948         "GET FIRMWARE STATUS",
3949         "GET LOOP ID",                  /* 20h */
3950         NULL,
3951         "GET TIMEOUT PARAMS",
3952         NULL,
3953         NULL,
3954         NULL,
3955         NULL,
3956         NULL,
3957         "GET FIRMWARE OPTIONS",
3958         "GET PORT QUEUE PARAMS",
3959         "GENERATE SYSTEM ERROR",
3960         NULL,
3961         NULL,
3962         NULL,
3963         NULL,
3964         NULL,
3965         "WRITE SFP",                    /* 30h */
3966         "READ SFP",
3967         "SET TIMEOUT PARAMS",
3968         NULL,
3969         NULL,
3970         NULL,
3971         NULL,
3972         NULL,
3973         "SET FIRMWARE OPTIONS",
3974         "SET PORT QUEUE PARAMS",
3975         NULL,
3976         "SET FC LED CONF",
3977         NULL,
3978         "RESTART NIC FIRMWARE",
3979         "ACCESS CONTROL",
3980         NULL,
3981         "LOOP PORT BYPASS",             /* 40h */
3982         "LOOP PORT ENABLE",
3983         "GET RESOURCE COUNT",
3984         "REQUEST NON PARTICIPATING MODE",
3985         "DIAGNOSTIC ECHO TEST",
3986         "DIAGNOSTIC LOOPBACK",
3987         NULL,
3988         "GET PORT DATABASE ENHANCED",
3989         "INIT FIRMWARE MULTI ID",
3990         "GET VP DATABASE",
3991         "GET VP DATABASE ENTRY",
3992         NULL,
3993         NULL,
3994         NULL,
3995         NULL,
3996         NULL,
3997         "GET FCF LIST",                 /* 50h */
3998         "GET DCBX PARAMETERS",
3999         NULL,
4000         "HOST MEMORY COPY",
4001         "EXECUTE IOCB A64",
4002         NULL,
4003         NULL,
4004         "SEND RNID",
4005         NULL,
4006         "SET PARAMETERS",
4007         "GET PARAMETERS",
4008         "DRIVER HEARTBEAT",
4009         "FIRMWARE HEARTBEAT",
4010         "GET/SET DATA RATE",
4011         "SEND RNFT",
4012         NULL,
4013         "INIT FIRMWARE",                /* 60h */
4014         "GET INIT CONTROL BLOCK",
4015         "INIT LIP",
4016         "GET FC-AL POSITION MAP",
4017         "GET PORT DATABASE",
4018         "CLEAR ACA",
4019         "TARGET RESET",
4020         "CLEAR TASK SET",
4021         "ABORT TASK SET",
4022         "GET FW STATE",
4023         "GET PORT NAME",
4024         "GET LINK STATUS",
4025         "INIT LIP RESET",
4026         "GET LINK STATS & PRIVATE DATA CNTS",
4027         "SEND SNS",
4028         "FABRIC LOGIN",
4029         "SEND CHANGE REQUEST",          /* 70h */
4030         "FABRIC LOGOUT",
4031         "INIT LIP LOGIN",
4032         NULL,
4033         "LOGIN LOOP PORT",
4034         "GET PORT/NODE NAME LIST",
4035         "SET VENDOR ID",
4036         "INITIALIZE IP MAILBOX",
4037         NULL,
4038         NULL,
4039         "GET XGMAC STATS",
4040         NULL,
4041         "GET ID LIST",
4042         "SEND LFA",
4043         "LUN RESET"
4044 };
4045
4046 static void
4047 isp_mboxcmd(ispsoftc_t *isp, mbreg_t *mbp)
4048 {
4049         const char *cname, *xname, *sname;
4050         char tname[16], mname[16];
4051         unsigned int ibits, obits, box, opcode, t, to;
4052
4053         opcode = mbp->param[0];
4054         if (opcode > MAX_FC_OPCODE) {
4055                 mbp->param[0] = MBOX_INVALID_COMMAND;
4056                 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
4057                 return;
4058         }
4059         cname = fc_mbcmd_names[opcode];
4060         ibits = ISP_FC_IBITS(opcode);
4061         obits = ISP_FC_OBITS(opcode);
4062         if (cname == NULL) {
4063                 cname = tname;
4064                 ISP_SNPRINTF(tname, sizeof tname, "opcode %x", opcode);
4065         }
4066         isp_prt(isp, ISP_LOGDEBUG3, "Mailbox Command '%s'", cname);
4067
4068         /*
4069          * Pick up any additional bits that the caller might have set.
4070          */
4071         ibits |= mbp->ibits;
4072         obits |= mbp->obits;
4073
4074         /*
4075          * Mask any bits that the caller wants us to mask
4076          */
4077         ibits &= mbp->ibitm;
4078         obits &= mbp->obitm;
4079
4080
4081         if (ibits == 0 && obits == 0) {
4082                 mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
4083                 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
4084                 return;
4085         }
4086
4087         for (box = 0; box < ISP_NMBOX(isp); box++) {
4088                 if (ibits & (1 << box)) {
4089                         isp_prt(isp, ISP_LOGDEBUG3, "IN mbox %d = 0x%04x", box,
4090                             mbp->param[box]);
4091                         ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
4092                 }
4093                 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
4094         }
4095
4096         isp->isp_obits = obits;
4097         isp->isp_mboxbsy = 1;
4098
4099         /*
4100          * Set Host Interrupt condition so that RISC will pick up mailbox regs.
4101          */
4102         ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
4103
4104         /*
4105          * While we haven't finished the command, spin our wheels here.
4106          */
4107         to = (mbp->timeout == 0) ? MBCMD_DEFAULT_TIMEOUT : mbp->timeout;
4108         for (t = 0; t < to; t += 100) {
4109                 if (!isp->isp_mboxbsy)
4110                         break;
4111                 ISP_RUN_ISR(isp);
4112                 if (!isp->isp_mboxbsy)
4113                         break;
4114                 ISP_DELAY(100);
4115         }
4116
4117         /*
4118          * Did the command time out?
4119          */
4120         if (isp->isp_mboxbsy) {
4121                 isp->isp_mboxbsy = 0;
4122                 isp_prt(isp, ISP_LOGWARN, "Mailbox Command (0x%x) Timeout (%uus) (%s:%d)",
4123                     opcode, to, mbp->func, mbp->lineno);
4124                 mbp->param[0] = MBOX_TIMEOUT;
4125                 goto out;
4126         }
4127
4128         /*
4129          * Copy back output registers.
4130          */
4131         for (box = 0; box < ISP_NMBOX(isp); box++) {
4132                 if (obits & (1 << box)) {
4133                         mbp->param[box] = isp->isp_mboxtmp[box];
4134                         isp_prt(isp, ISP_LOGDEBUG3, "OUT mbox %d = 0x%04x", box,
4135                             mbp->param[box]);
4136                 }
4137         }
4138
4139 out:
4140         if (mbp->logval == 0 || mbp->param[0] == MBOX_COMMAND_COMPLETE)
4141                 return;
4142
4143         if ((mbp->param[0] & 0xbfe0) == 0 &&
4144             (mbp->logval & MBLOGMASK(mbp->param[0])) == 0)
4145                 return;
4146
4147         xname = NULL;
4148         sname = "";
4149         switch (mbp->param[0]) {
4150         case MBOX_INVALID_COMMAND:
4151                 xname = "INVALID COMMAND";
4152                 break;
4153         case MBOX_HOST_INTERFACE_ERROR:
4154                 xname = "HOST INTERFACE ERROR";
4155                 break;
4156         case MBOX_TEST_FAILED:
4157                 xname = "TEST FAILED";
4158                 break;
4159         case MBOX_COMMAND_ERROR:
4160                 xname = "COMMAND ERROR";
4161                 ISP_SNPRINTF(mname, sizeof(mname), " subcode 0x%x",
4162                     mbp->param[1]);
4163                 sname = mname;
4164                 break;
4165         case MBOX_COMMAND_PARAM_ERROR:
4166                 xname = "COMMAND PARAMETER ERROR";
4167                 break;
4168         case MBOX_PORT_ID_USED:
4169                 xname = "PORT ID ALREADY IN USE";
4170                 break;
4171         case MBOX_LOOP_ID_USED:
4172                 xname = "LOOP ID ALREADY IN USE";
4173                 break;
4174         case MBOX_ALL_IDS_USED:
4175                 xname = "ALL LOOP IDS IN USE";
4176                 break;
4177         case MBOX_NOT_LOGGED_IN:
4178                 xname = "NOT LOGGED IN";
4179                 break;
4180         case MBOX_LINK_DOWN_ERROR:
4181                 xname = "LINK DOWN ERROR";
4182                 break;
4183         case MBOX_LOOPBACK_ERROR:
4184                 xname = "LOOPBACK ERROR";
4185                 break;
4186         case MBOX_CHECKSUM_ERROR:
4187                 xname = "CHECKSUM ERROR";
4188                 break;
4189         case MBOX_INVALID_PRODUCT_KEY:
4190                 xname = "INVALID PRODUCT KEY";
4191                 break;
4192         case MBOX_REGS_BUSY:
4193                 xname = "REGISTERS BUSY";
4194                 break;
4195         case MBOX_TIMEOUT:
4196                 xname = "TIMEOUT";
4197                 break;
4198         default:
4199                 ISP_SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
4200                 xname = mname;
4201                 break;
4202         }
4203         if (xname) {
4204                 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s%s)",
4205                     cname, xname, sname);
4206         }
4207 }
4208
4209 static int
4210 isp_fw_state(ispsoftc_t *isp, int chan)
4211 {
4212         mbreg_t mbs;
4213
4214         MBSINIT(&mbs, MBOX_GET_FW_STATE, MBLOGALL, 0);
4215         isp_mboxcmd(isp, &mbs);
4216         if (mbs.param[0] == MBOX_COMMAND_COMPLETE)
4217                 return (mbs.param[1]);
4218         return (FW_ERROR);
4219 }
4220
4221 static void
4222 isp_setdfltfcparm(ispsoftc_t *isp, int chan)
4223 {
4224         fcparam *fcp = FCPARAM(isp, chan);
4225
4226         /*
4227          * Establish some default parameters.
4228          */
4229         fcp->role = DEFAULT_ROLE(isp, chan);
4230         fcp->isp_retry_delay = ICB_DFLT_RDELAY;
4231         fcp->isp_retry_count = ICB_DFLT_RCOUNT;
4232         fcp->isp_loopid = DEFAULT_LOOPID(isp, chan);
4233         fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp, chan);
4234         fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp, chan);
4235         fcp->isp_fwoptions = 0;
4236         fcp->isp_xfwoptions = 0;
4237         fcp->isp_zfwoptions = 0;
4238         fcp->isp_lasthdl = NIL_HANDLE;
4239         fcp->isp_login_hdl = NIL_HANDLE;
4240
4241         fcp->isp_fwoptions |= ICB2400_OPT1_FAIRNESS;
4242         fcp->isp_fwoptions |= ICB2400_OPT1_HARD_ADDRESS;
4243         if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
4244                 fcp->isp_fwoptions |= ICB2400_OPT1_FULL_DUPLEX;
4245         fcp->isp_fwoptions |= ICB2400_OPT1_BOTH_WWNS;
4246         fcp->isp_xfwoptions |= ICB2400_OPT2_LOOP_2_PTP;
4247         fcp->isp_zfwoptions |= ICB2400_OPT3_RATE_AUTO;
4248
4249         /*
4250          * Now try and read NVRAM unless told to not do so.
4251          * This will set fcparam's isp_wwnn_nvram && isp_wwpn_nvram.
4252          */
4253         if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
4254                 int i, j = 0;
4255                 /*
4256                  * Give a couple of tries at reading NVRAM.
4257                  */
4258                 for (i = 0; i < 2; i++) {
4259                         j = isp_read_nvram(isp, chan);
4260                         if (j == 0) {
4261                                 break;
4262                         }
4263                 }
4264                 if (j) {
4265                         isp->isp_confopts |= ISP_CFG_NONVRAM;
4266                 }
4267         }
4268
4269         fcp->isp_wwnn = ACTIVE_NODEWWN(isp, chan);
4270         fcp->isp_wwpn = ACTIVE_PORTWWN(isp, chan);
4271         isp_prt(isp, ISP_LOGCONFIG, "Chan %d 0x%08x%08x/0x%08x%08x Role %s",
4272             chan, (uint32_t) (fcp->isp_wwnn >> 32), (uint32_t) (fcp->isp_wwnn),
4273             (uint32_t) (fcp->isp_wwpn >> 32), (uint32_t) (fcp->isp_wwpn),
4274             isp_class3_roles[fcp->role]);
4275 }
4276
4277 /*
4278  * Re-initialize the ISP and complete all orphaned commands
4279  * with a 'botched' notice. The reset/init routines should
4280  * not disturb an already active list of commands.
4281  */
4282
4283 int
4284 isp_reinit(ispsoftc_t *isp, int do_load_defaults)
4285 {
4286         int i, res = 0;
4287
4288         if (isp->isp_state > ISP_RESETSTATE)
4289                 isp_stop(isp);
4290         if (isp->isp_state != ISP_RESETSTATE)
4291                 isp_reset(isp, do_load_defaults);
4292         if (isp->isp_state != ISP_RESETSTATE) {
4293                 res = EIO;
4294                 isp_prt(isp, ISP_LOGERR, "%s: cannot reset card", __func__);
4295                 goto cleanup;
4296         }
4297
4298         isp_init(isp);
4299         if (isp->isp_state > ISP_RESETSTATE &&
4300             isp->isp_state != ISP_RUNSTATE) {
4301                 res = EIO;
4302                 isp_prt(isp, ISP_LOGERR, "%s: cannot init card", __func__);
4303                 ISP_DISABLE_INTS(isp);
4304         }
4305
4306 cleanup:
4307         isp_clear_commands(isp);
4308         for (i = 0; i < isp->isp_nchan; i++)
4309                 isp_clear_portdb(isp, i);
4310         return (res);
4311 }
4312
4313 /*
4314  * NVRAM Routines
4315  */
4316 static int
4317 isp_read_nvram(ispsoftc_t *isp, int bus)
4318 {
4319
4320         return (isp_read_nvram_2400(isp));
4321 }
4322
4323 static int
4324 isp_read_nvram_2400(ispsoftc_t *isp)
4325 {
4326         int retval = 0;
4327         uint32_t addr, csum, lwrds, *dptr;
4328         uint8_t nvram_data[ISP2400_NVRAM_SIZE];
4329
4330         if (isp->isp_port) {
4331                 addr = ISP2400_NVRAM_PORT1_ADDR;
4332         } else {
4333                 addr = ISP2400_NVRAM_PORT0_ADDR;
4334         }
4335
4336         dptr = (uint32_t *) nvram_data;
4337         for (lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
4338                 isp_rd_2400_nvram(isp, addr++, dptr++);
4339         }
4340         if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
4341             nvram_data[2] != 'P') {
4342                 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header (%x %x %x)",
4343                     nvram_data[0], nvram_data[1], nvram_data[2]);
4344                 retval = -1;
4345                 goto out;
4346         }
4347         dptr = (uint32_t *) nvram_data;
4348         for (csum = 0, lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
4349                 uint32_t tmp;
4350                 ISP_IOXGET_32(isp, &dptr[lwrds], tmp);
4351                 csum += tmp;
4352         }
4353         if (csum != 0) {
4354                 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
4355                 retval = -1;
4356                 goto out;
4357         }
4358         isp_parse_nvram_2400(isp, nvram_data);
4359 out:
4360         return (retval);
4361 }
4362
4363 static void
4364 isp_rd_2400_nvram(ispsoftc_t *isp, uint32_t addr, uint32_t *rp)
4365 {
4366         int loops = 0;
4367         uint32_t base = 0x7ffe0000;
4368         uint32_t tmp = 0;
4369
4370         if (IS_26XX(isp)) {
4371                 base = 0x7fe7c000;      /* XXX: Observation, may be wrong. */
4372         } else if (IS_25XX(isp)) {
4373                 base = 0x7ff00000 | 0x48000;
4374         }
4375         ISP_WRITE(isp, BIU2400_FLASH_ADDR, base | addr);
4376         for (loops = 0; loops < 5000; loops++) {
4377                 ISP_DELAY(10);
4378                 tmp = ISP_READ(isp, BIU2400_FLASH_ADDR);
4379                 if ((tmp & (1U << 31)) != 0) {
4380                         break;
4381                 }
4382         }
4383         if (tmp & (1U << 31)) {
4384                 *rp = ISP_READ(isp, BIU2400_FLASH_DATA);
4385                 ISP_SWIZZLE_NVRAM_LONG(isp, rp);
4386         } else {
4387                 *rp = 0xffffffff;
4388         }
4389 }
4390
4391 static void
4392 isp_parse_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
4393 {
4394         fcparam *fcp = FCPARAM(isp, 0);
4395         uint64_t wwn;
4396
4397         isp_prt(isp, ISP_LOGDEBUG0,
4398             "NVRAM 0x%08x%08x 0x%08x%08x maxframelen %d",
4399             (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data) >> 32),
4400             (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data)),
4401             (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data) >> 32),
4402             (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data)),
4403             ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data));
4404         isp_prt(isp, ISP_LOGDEBUG0,
4405             "NVRAM loopid %d fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
4406             ISP2400_NVRAM_HARDLOOPID(nvram_data),
4407             ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data),
4408             ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data),
4409             ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data));
4410
4411         wwn = ISP2400_NVRAM_PORT_NAME(nvram_data);
4412         fcp->isp_wwpn_nvram = wwn;
4413
4414         wwn = ISP2400_NVRAM_NODE_NAME(nvram_data);
4415         if (wwn) {
4416                 if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
4417                         wwn = 0;
4418                 }
4419         }
4420         if (wwn == 0 && (fcp->isp_wwpn_nvram >> 60) == 2) {
4421                 wwn = fcp->isp_wwpn_nvram;
4422                 wwn &= ~((uint64_t) 0xfff << 48);
4423         }
4424         fcp->isp_wwnn_nvram = wwn;
4425
4426         if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
4427                 DEFAULT_FRAMESIZE(isp) =
4428                     ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data);
4429         }
4430         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
4431                 fcp->isp_loopid = ISP2400_NVRAM_HARDLOOPID(nvram_data);
4432         }
4433         fcp->isp_fwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data);
4434         fcp->isp_xfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data);
4435         fcp->isp_zfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data);
4436 }