sys/dev/isp/isp.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  *  Copyright (c) 2009-2017 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  * General defines
  68  */
  69 #define MBOX_DELAY_COUNT        1000000 / 100
  70
  71 /*
  72  * Local static data
  73  */
  74 static const char notresp[] = "Unknown IOCB in RESPONSE Queue (type 0x%x) @ idx %d (next %d)";
  75 static const char bun[] = "bad underrun (count %d, resid %d, status %s)";
  76 static const char lipd[] = "Chan %d LIP destroyed %d active commands";
  77 static const char sacq[] = "unable to acquire scratch area";
  78
  79 static const uint8_t alpa_map[] = {
  80         0xef, 0xe8, 0xe4, 0xe2, 0xe1, 0xe0, 0xdc, 0xda,
  81         0xd9, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xce,
  82         0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc7, 0xc6, 0xc5,
  83         0xc3, 0xbc, 0xba, 0xb9, 0xb6, 0xb5, 0xb4, 0xb3,
  84         0xb2, 0xb1, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9,
  85         0xa7, 0xa6, 0xa5, 0xa3, 0x9f, 0x9e, 0x9d, 0x9b,
  86         0x98, 0x97, 0x90, 0x8f, 0x88, 0x84, 0x82, 0x81,
  87         0x80, 0x7c, 0x7a, 0x79, 0x76, 0x75, 0x74, 0x73,
  88         0x72, 0x71, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69,
  89         0x67, 0x66, 0x65, 0x63, 0x5c, 0x5a, 0x59, 0x56,
  90         0x55, 0x54, 0x53, 0x52, 0x51, 0x4e, 0x4d, 0x4c,
  91         0x4b, 0x4a, 0x49, 0x47, 0x46, 0x45, 0x43, 0x3c,
  92         0x3a, 0x39, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31,
  93         0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x27, 0x26,
  94         0x25, 0x23, 0x1f, 0x1e, 0x1d, 0x1b, 0x18, 0x17,
  95         0x10, 0x0f, 0x08, 0x04, 0x02, 0x01, 0x00
  96 };
  97
  98 /*
  99  * Local function prototypes.
 100  */
 101 static void isp_parse_async(ispsoftc_t *, uint16_t);
 102 static void isp_parse_async_fc(ispsoftc_t *, uint16_t);
 103 static int isp_handle_other_response(ispsoftc_t *, int, isphdr_t *, uint32_t *);
 104 static void isp_parse_status(ispsoftc_t *, ispstatusreq_t *, XS_T *, uint32_t *);
 105 static void isp_parse_status_24xx(ispsoftc_t *, isp24xx_statusreq_t *, XS_T *, uint32_t *);
 106 static void isp_fastpost_complete(ispsoftc_t *, uint32_t);
 107 static void isp_scsi_init(ispsoftc_t *);
 108 static void isp_scsi_channel_init(ispsoftc_t *, int);
 109 static void isp_fibre_init(ispsoftc_t *);
 110 static void isp_fibre_init_2400(ispsoftc_t *);
 111 static void isp_clear_portdb(ispsoftc_t *, int);
 112 static void isp_mark_portdb(ispsoftc_t *, int);
 113 static int isp_plogx(ispsoftc_t *, int, uint16_t, uint32_t, int);
 114 static int isp_port_login(ispsoftc_t *, uint16_t, uint32_t);
 115 static int isp_port_logout(ispsoftc_t *, uint16_t, uint32_t);
 116 static int isp_getpdb(ispsoftc_t *, int, uint16_t, isp_pdb_t *);
 117 static int isp_gethandles(ispsoftc_t *, int, uint16_t *, int *, int);
 118 static void isp_dump_chip_portdb(ispsoftc_t *, int);
 119 static uint64_t isp_get_wwn(ispsoftc_t *, int, int, int);
 120 static int isp_fclink_test(ispsoftc_t *, int, int);
 121 static int isp_pdb_sync(ispsoftc_t *, int);
 122 static int isp_scan_loop(ispsoftc_t *, int);
 123 static int isp_gid_pt(ispsoftc_t *, int);
 124 static int isp_scan_fabric(ispsoftc_t *, int);
 125 static int isp_login_device(ispsoftc_t *, int, uint32_t, isp_pdb_t *, uint16_t *);
 126 static int isp_send_change_request(ispsoftc_t *, int);
 127 static int isp_register_fc4_type(ispsoftc_t *, int);
 128 static int isp_register_fc4_features_24xx(ispsoftc_t *, int);
 129 static int isp_register_port_name_24xx(ispsoftc_t *, int);
 130 static int isp_register_node_name_24xx(ispsoftc_t *, int);
 131 static uint16_t isp_next_handle(ispsoftc_t *, uint16_t *);
 132 static int isp_fw_state(ispsoftc_t *, int);
 133 static void isp_mboxcmd(ispsoftc_t *, mbreg_t *);
 134
 135 static void isp_spi_update(ispsoftc_t *, int);
 136 static void isp_setdfltsdparm(ispsoftc_t *);
 137 static void isp_setdfltfcparm(ispsoftc_t *, int);
 138 static int isp_read_nvram(ispsoftc_t *, int);
 139 static int isp_read_nvram_2400(ispsoftc_t *, uint8_t *);
 140 static void isp_rdnvram_word(ispsoftc_t *, int, uint16_t *);
 141 static void isp_rd_2400_nvram(ispsoftc_t *, uint32_t, uint32_t *);
 142 static void isp_parse_nvram_1020(ispsoftc_t *, uint8_t *);
 143 static void isp_parse_nvram_1080(ispsoftc_t *, int, uint8_t *);
 144 static void isp_parse_nvram_12160(ispsoftc_t *, int, uint8_t *);
 145 static void isp_parse_nvram_2100(ispsoftc_t *, uint8_t *);
 146 static void isp_parse_nvram_2400(ispsoftc_t *, uint8_t *);
 147
 148 static void
 149 isp_change_fw_state(ispsoftc_t *isp, int chan, int state)
 150 {
 151         fcparam *fcp = FCPARAM(isp, chan);
 152
 153         if (fcp->isp_fwstate == state)
 154                 return;
 155         isp_prt(isp, ISP_LOGCONFIG|ISP_LOG_SANCFG,
 156             "Chan %d Firmware state <%s->%s>", chan,
 157             isp_fc_fw_statename(fcp->isp_fwstate), isp_fc_fw_statename(state));
 158         fcp->isp_fwstate = state;
 159 }
 160
 161 /*
 162  * Reset Hardware.
 163  *
 164  * Hit the chip over the head, download new f/w if available and set it running.
 165  *
 166  * Locking done elsewhere.
 167  */
 168
 169 void
 170 isp_reset(ispsoftc_t *isp, int do_load_defaults)
 171 {
 172         mbreg_t mbs;
 173         char *buf;
 174         uint64_t fwt;
 175         uint32_t code_org, val;
 176         int loops, i, dodnld = 1;
 177         const char *btype = "????";
 178         static const char dcrc[] = "Downloaded RISC Code Checksum Failure";
 179
 180         /*
 181          * Basic types (SCSI, FibreChannel and PCI or SBus)
 182          * have been set in the MD code. We figure out more
 183          * here. Possibly more refined types based upon PCI
 184          * identification. Chip revision has been gathered.
 185          *
 186          * After we've fired this chip up, zero out the conf1 register
 187          * for SCSI adapters and do other settings for the 2100.
 188          */
 189
 190         isp->isp_state = ISP_NILSTATE;
 191         ISP_DISABLE_INTS(isp);
 192
 193         /*
 194          * Put the board into PAUSE mode (so we can read the SXP registers
 195          * or write FPM/FBM registers).
 196          */
 197         if (IS_24XX(isp)) {
 198                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_HOST_INT);
 199                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
 200                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
 201         } else {
 202                 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
 203         }
 204
 205         if (IS_FC(isp)) {
 206                 switch (isp->isp_type) {
 207                 case ISP_HA_FC_2100:
 208                         btype = "2100";
 209                         break;
 210                 case ISP_HA_FC_2200:
 211                         btype = "2200";
 212                         break;
 213                 case ISP_HA_FC_2300:
 214                         btype = "2300";
 215                         break;
 216                 case ISP_HA_FC_2312:
 217                         btype = "2312";
 218                         break;
 219                 case ISP_HA_FC_2322:
 220                         btype = "2322";
 221                         break;
 222                 case ISP_HA_FC_2400:
 223                         btype = "2422";
 224                         break;
 225                 case ISP_HA_FC_2500:
 226                         btype = "2532";
 227                         break;
 228                 case ISP_HA_FC_2600:
 229                         btype = "2031";
 230                         break;
 231                 default:
 232                         break;
 233                 }
 234
 235                 if (!IS_24XX(isp)) {
 236                         /*
 237                          * While we're paused, reset the FPM module and FBM
 238                          * fifos.
 239                          */
 240                         ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
 241                         ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
 242                         ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
 243                         ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
 244                         ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
 245                 }
 246         } else if (IS_1240(isp)) {
 247                 sdparam *sdp;
 248
 249                 btype = "1240";
 250                 isp->isp_clock = 60;
 251                 sdp = SDPARAM(isp, 0);
 252                 sdp->isp_ultramode = 1;
 253                 sdp = SDPARAM(isp, 1);
 254                 sdp->isp_ultramode = 1;
 255                 /*
 256                  * XXX: Should probably do some bus sensing.
 257                  */
 258         } else if (IS_ULTRA3(isp)) {
 259                 sdparam *sdp = isp->isp_param;
 260
 261                 isp->isp_clock = 100;
 262
 263                 if (IS_10160(isp))
 264                         btype = "10160";
 265                 else if (IS_12160(isp))
 266                         btype = "12160";
 267                 else
 268                         btype = "<UNKLVD>";
 269                 sdp->isp_lvdmode = 1;
 270
 271                 if (IS_DUALBUS(isp)) {
 272                         sdp++;
 273                         sdp->isp_lvdmode = 1;
 274                 }
 275         } else if (IS_ULTRA2(isp)) {
 276                 static const char m[] = "bus %d is in %s Mode";
 277                 uint16_t l;
 278                 sdparam *sdp = SDPARAM(isp, 0);
 279
 280                 isp->isp_clock = 100;
 281
 282                 if (IS_1280(isp))
 283                         btype = "1280";
 284                 else if (IS_1080(isp))
 285                         btype = "1080";
 286                 else
 287                         btype = "<UNKLVD>";
 288
 289                 l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
 290                 switch (l) {
 291                 case ISP1080_LVD_MODE:
 292                         sdp->isp_lvdmode = 1;
 293                         isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
 294                         break;
 295                 case ISP1080_HVD_MODE:
 296                         sdp->isp_diffmode = 1;
 297                         isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
 298                         break;
 299                 case ISP1080_SE_MODE:
 300                         sdp->isp_ultramode = 1;
 301                         isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
 302                         break;
 303                 default:
 304                         isp_prt(isp, ISP_LOGERR,
 305                             "unknown mode on bus %d (0x%x)", 0, l);
 306                         break;
 307                 }
 308
 309                 if (IS_DUALBUS(isp)) {
 310                         sdp = SDPARAM(isp, 1);
 311                         l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
 312                         l &= ISP1080_MODE_MASK;
 313                         switch (l) {
 314                         case ISP1080_LVD_MODE:
 315                                 sdp->isp_lvdmode = 1;
 316                                 isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
 317                                 break;
 318                         case ISP1080_HVD_MODE:
 319                                 sdp->isp_diffmode = 1;
 320                                 isp_prt(isp, ISP_LOGCONFIG,
 321                                     m, 1, "Differential");
 322                                 break;
 323                         case ISP1080_SE_MODE:
 324                                 sdp->isp_ultramode = 1;
 325                                 isp_prt(isp, ISP_LOGCONFIG,
 326                                     m, 1, "Single-Ended");
 327                                 break;
 328                         default:
 329                                 isp_prt(isp, ISP_LOGERR,
 330                                     "unknown mode on bus %d (0x%x)", 1, l);
 331                                 break;
 332                         }
 333                 }
 334         } else {
 335                 sdparam *sdp = SDPARAM(isp, 0);
 336                 i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
 337                 switch (i) {
 338                 default:
 339                         isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
 340                         /* FALLTHROUGH */
 341                 case 1:
 342                         btype = "1020";
 343                         isp->isp_type = ISP_HA_SCSI_1020;
 344                         isp->isp_clock = 40;
 345                         break;
 346                 case 2:
 347                         /*
 348                          * Some 1020A chips are Ultra Capable, but don't
 349                          * run the clock rate up for that unless told to
 350                          * do so by the Ultra Capable bits being set.
 351                          */
 352                         btype = "1020A";
 353                         isp->isp_type = ISP_HA_SCSI_1020A;
 354                         isp->isp_clock = 40;
 355                         break;
 356                 case 3:
 357                         btype = "1040";
 358                         isp->isp_type = ISP_HA_SCSI_1040;
 359                         isp->isp_clock = 60;
 360                         break;
 361                 case 4:
 362                         btype = "1040A";
 363                         isp->isp_type = ISP_HA_SCSI_1040A;
 364                         isp->isp_clock = 60;
 365                         break;
 366                 case 5:
 367                         btype = "1040B";
 368                         isp->isp_type = ISP_HA_SCSI_1040B;
 369                         isp->isp_clock = 60;
 370                         break;
 371                 case 6:
 372                         btype = "1040C";
 373                         isp->isp_type = ISP_HA_SCSI_1040C;
 374                         isp->isp_clock = 60;
 375                         break;
 376                 }
 377                 /*
 378                  * Now, while we're at it, gather info about ultra
 379                  * and/or differential mode.
 380                  */
 381                 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
 382                         isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
 383                         sdp->isp_diffmode = 1;
 384                 } else {
 385                         sdp->isp_diffmode = 0;
 386                 }
 387                 i = ISP_READ(isp, RISC_PSR);
 388                 if (isp->isp_bustype == ISP_BT_SBUS) {
 389                         i &= RISC_PSR_SBUS_ULTRA;
 390                 } else {
 391                         i &= RISC_PSR_PCI_ULTRA;
 392                 }
 393                 if (i != 0) {
 394                         isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
 395                         sdp->isp_ultramode = 1;
 396                         /*
 397                          * If we're in Ultra Mode, we have to be 60MHz clock-
 398                          * even for the SBus version.
 399                          */
 400                         isp->isp_clock = 60;
 401                 } else {
 402                         sdp->isp_ultramode = 0;
 403                         /*
 404                          * Clock is known. Gronk.
 405                          */
 406                 }
 407
 408                 /*
 409                  * Machine dependent clock (if set) overrides
 410                  * our generic determinations.
 411                  */
 412                 if (isp->isp_mdvec->dv_clock) {
 413                         if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
 414                                 isp->isp_clock = isp->isp_mdvec->dv_clock;
 415                         }
 416                 }
 417         }
 418
 419         /*
 420          * Hit the chip over the head with hammer,
 421          * and give it a chance to recover.
 422          */
 423
 424         if (IS_SCSI(isp)) {
 425                 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
 426                 /*
 427                  * A slight delay...
 428                  */
 429                 ISP_DELAY(100);
 430
 431                 /*
 432                  * Clear data && control DMA engines.
 433                  */
 434                 ISP_WRITE(isp, CDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
 435                 ISP_WRITE(isp, DDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
 436
 437
 438         } else if (IS_24XX(isp)) {
 439                 /*
 440                  * Stop DMA and wait for it to stop.
 441                  */
 442                 ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
 443                 for (val = loops = 0; loops < 30000; loops++) {
 444                         ISP_DELAY(10);
 445                         val = ISP_READ(isp, BIU2400_CSR);
 446                         if ((val & BIU2400_DMA_ACTIVE) == 0) {
 447                                 break;
 448                         }
 449                 }
 450                 if (val & BIU2400_DMA_ACTIVE) {
 451                         isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
 452                         return;
 453                 }
 454                 /*
 455                  * Hold it in SOFT_RESET and STOP state for 100us.
 456                  */
 457                 ISP_WRITE(isp, BIU2400_CSR, BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
 458                 ISP_DELAY(100);
 459                 for (loops = 0; loops < 10000; loops++) {
 460                         ISP_DELAY(5);
 461                         val = ISP_READ(isp, OUTMAILBOX0);
 462                 }
 463                 for (val = loops = 0; loops < 500000; loops ++) {
 464                         val = ISP_READ(isp, BIU2400_CSR);
 465                         if ((val & BIU2400_SOFT_RESET) == 0) {
 466                                 break;
 467                         }
 468                 }
 469                 if (val & BIU2400_SOFT_RESET) {
 470                         isp_prt(isp, ISP_LOGERR, "Failed to come out of reset");
 471                         return;
 472                 }
 473         } else {
 474                 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
 475                 /*
 476                  * A slight delay...
 477                  */
 478                 ISP_DELAY(100);
 479
 480                 /*
 481                  * Clear data && control DMA engines.
 482                  */
 483                 ISP_WRITE(isp, CDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
 484                 ISP_WRITE(isp, TDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
 485                 ISP_WRITE(isp, RDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
 486         }
 487
 488         /*
 489          * Wait for ISP to be ready to go...
 490          */
 491         loops = MBOX_DELAY_COUNT;
 492         for (;;) {
 493                 if (IS_SCSI(isp)) {
 494                         if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) {
 495                                 break;
 496                         }
 497                 } else if (IS_24XX(isp)) {
 498                         if (ISP_READ(isp, OUTMAILBOX0) == 0) {
 499                                 break;
 500                         }
 501                 } else {
 502                         if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
 503                                 break;
 504                 }
 505                 ISP_DELAY(100);
 506                 if (--loops < 0) {
 507                         ISP_DUMPREGS(isp, "chip reset timed out");
 508                         return;
 509                 }
 510         }
 511
 512         /*
 513          * After we've fired this chip up, zero out the conf1 register
 514          * for SCSI adapters and other settings for the 2100.
 515          */
 516
 517         if (IS_SCSI(isp)) {
 518                 ISP_WRITE(isp, BIU_CONF1, 0);
 519         } else if (!IS_24XX(isp)) {
 520                 ISP_WRITE(isp, BIU2100_CSR, 0);
 521         }
 522
 523         /*
 524          * Reset RISC Processor
 525          */
 526         if (IS_24XX(isp)) {
 527                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
 528                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
 529                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
 530         } else {
 531                 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
 532                 ISP_DELAY(100);
 533                 ISP_WRITE(isp, BIU_SEMA, 0);
 534         }
 535
 536         /*
 537          * Post-RISC Reset stuff.
 538          */
 539         if (IS_24XX(isp)) {
 540                 for (val = loops = 0; loops < 5000000; loops++) {
 541                         ISP_DELAY(5);
 542                         val = ISP_READ(isp, OUTMAILBOX0);
 543                         if (val == 0) {
 544                                 break;
 545                         }
 546                 }
 547                 if (val != 0) {
 548                         isp_prt(isp, ISP_LOGERR, "reset didn't clear");
 549                         return;
 550                 }
 551         } else if (IS_SCSI(isp)) {
 552                 uint16_t tmp = isp->isp_mdvec->dv_conf1;
 553                 /*
 554                  * Busted FIFO. Turn off all but burst enables.
 555                  */
 556                 if (isp->isp_type == ISP_HA_SCSI_1040A) {
 557                         tmp &= BIU_BURST_ENABLE;
 558                 }
 559                 ISP_SETBITS(isp, BIU_CONF1, tmp);
 560                 if (tmp & BIU_BURST_ENABLE) {
 561                         ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
 562                         ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
 563                 }
 564                 if (SDPARAM(isp, 0)->isp_ptisp) {
 565                         if (SDPARAM(isp, 0)->isp_ultramode) {
 566                                 while (ISP_READ(isp, RISC_MTR) != 0x1313) {
 567                                         ISP_WRITE(isp, RISC_MTR, 0x1313);
 568                                         ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
 569                                 }
 570                         } else {
 571                                 ISP_WRITE(isp, RISC_MTR, 0x1212);
 572                         }
 573                         /*
 574                          * PTI specific register
 575                          */
 576                         ISP_WRITE(isp, RISC_EMB, DUAL_BANK);
 577                 } else {
 578                         ISP_WRITE(isp, RISC_MTR, 0x1212);
 579                 }
 580                 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
 581         } else {
 582                 ISP_WRITE(isp, RISC_MTR2100, 0x1212);
 583                 if (IS_2200(isp) || IS_23XX(isp)) {
 584                         ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
 585                 }
 586                 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
 587         }
 588
 589         /*
 590          * Set up default request/response queue in-pointer/out-pointer
 591          * register indices.
 592          */
 593         if (IS_24XX(isp)) {
 594                 isp->isp_rqstinrp = BIU2400_REQINP;
 595                 isp->isp_rqstoutrp = BIU2400_REQOUTP;
 596                 isp->isp_respinrp = BIU2400_RSPINP;
 597                 isp->isp_respoutrp = BIU2400_RSPOUTP;
 598         } else if (IS_23XX(isp)) {
 599                 isp->isp_rqstinrp = BIU_REQINP;
 600                 isp->isp_rqstoutrp = BIU_REQOUTP;
 601                 isp->isp_respinrp = BIU_RSPINP;
 602                 isp->isp_respoutrp = BIU_RSPOUTP;
 603         } else {
 604                 isp->isp_rqstinrp = INMAILBOX4;
 605                 isp->isp_rqstoutrp = OUTMAILBOX4;
 606                 isp->isp_respinrp = OUTMAILBOX5;
 607                 isp->isp_respoutrp = INMAILBOX5;
 608         }
 609         ISP_WRITE(isp, isp->isp_rqstinrp, 0);
 610         ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
 611         ISP_WRITE(isp, isp->isp_respinrp, 0);
 612         ISP_WRITE(isp, isp->isp_respoutrp, 0);
 613         if (IS_24XX(isp)) {
 614                 if (!IS_26XX(isp)) {
 615                         ISP_WRITE(isp, BIU2400_PRI_REQINP, 0);
 616                         ISP_WRITE(isp, BIU2400_PRI_REQOUTP, 0);
 617                 }
 618                 ISP_WRITE(isp, BIU2400_ATIO_RSPINP, 0);
 619                 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, 0);
 620         }
 621
 622         if (!IS_24XX(isp) && isp->isp_bustype == ISP_BT_PCI) {
 623                 /* Make sure the BIOS is disabled */
 624                 ISP_WRITE(isp, HCCR, PCI_HCCR_CMD_BIOS);
 625         }
 626
 627         /*
 628          * Wait for everything to finish firing up.
 629          *
 630          * Avoid doing this on early 2312s because you can generate a PCI
 631          * parity error (chip breakage).
 632          */
 633         if (IS_2312(isp) && isp->isp_revision < 2) {
 634                 ISP_DELAY(100);
 635         } else {
 636                 loops = MBOX_DELAY_COUNT;
 637                 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
 638                         ISP_DELAY(100);
 639                         if (--loops < 0) {
 640                                 isp_prt(isp, ISP_LOGERR, "MBOX_BUSY never cleared on reset");
 641                                 return;
 642                         }
 643                 }
 644         }
 645
 646         /*
 647          * Up until this point we've done everything by just reading or
 648          * setting registers. From this point on we rely on at least *some*
 649          * kind of firmware running in the card.
 650          */
 651
 652         /*
 653          * Do some sanity checking by running a NOP command.
 654          * If it succeeds, the ROM firmware is now running.
 655          */
 656         MBSINIT(&mbs, MBOX_NO_OP, MBLOGALL, 0);
 657         isp_mboxcmd(isp, &mbs);
 658         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 659                 isp_prt(isp, ISP_LOGERR, "NOP command failed (%x)", mbs.param[0]);
 660                 return;
 661         }
 662
 663         /*
 664          * Do some operational tests
 665          */
 666         if (IS_SCSI(isp) || IS_24XX(isp)) {
 667                 static const uint16_t patterns[MAX_MAILBOX] = {
 668                         0x0000, 0xdead, 0xbeef, 0xffff,
 669                         0xa5a5, 0x5a5a, 0x7f7f, 0x7ff7,
 670                         0x3421, 0xabcd, 0xdcba, 0xfeef,
 671                         0xbead, 0xdebe, 0x2222, 0x3333,
 672                         0x5555, 0x6666, 0x7777, 0xaaaa,
 673                         0xffff, 0xdddd, 0x9999, 0x1fbc,
 674                         0x6666, 0x6677, 0x1122, 0x33ff,
 675                         0x0000, 0x0001, 0x1000, 0x1010,
 676                 };
 677                 int nmbox = ISP_NMBOX(isp);
 678                 if (IS_SCSI(isp))
 679                         nmbox = 6;
 680                 MBSINIT(&mbs, MBOX_MAILBOX_REG_TEST, MBLOGALL, 0);
 681                 for (i = 1; i < nmbox; i++) {
 682                         mbs.param[i] = patterns[i];
 683                 }
 684                 isp_mboxcmd(isp, &mbs);
 685                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 686                         return;
 687                 }
 688                 for (i = 1; i < nmbox; i++) {
 689                         if (mbs.param[i] != patterns[i]) {
 690                                 isp_prt(isp, ISP_LOGERR, "Register Test Failed at Register %d: should have 0x%04x but got 0x%04x", i, patterns[i], mbs.param[i]);
 691                                 return;
 692                         }
 693                 }
 694         }
 695
 696         /*
 697          * Download new Firmware, unless requested not to do so.
 698          * This is made slightly trickier in some cases where the
 699          * firmware of the ROM revision is newer than the revision
 700          * compiled into the driver. So, where we used to compare
 701          * versions of our f/w and the ROM f/w, now we just see
 702          * whether we have f/w at all and whether a config flag
 703          * has disabled our download.
 704          */
 705         if ((isp->isp_mdvec->dv_ispfw == NULL) || (isp->isp_confopts & ISP_CFG_NORELOAD)) {
 706                 dodnld = 0;
 707         } else {
 708
 709                 /*
 710                  * Set up DMA for the request and response queues.
 711                  * We do this now so we can use the request queue
 712                  * for dma to load firmware from.
 713                  */
 714                 if (ISP_MBOXDMASETUP(isp) != 0) {
 715                         isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
 716                         return;
 717                 }
 718         }
 719
 720         if (IS_24XX(isp)) {
 721                 code_org = ISP_CODE_ORG_2400;
 722         } else if (IS_23XX(isp)) {
 723                 code_org = ISP_CODE_ORG_2300;
 724         } else {
 725                 code_org = ISP_CODE_ORG;
 726         }
 727
 728         isp->isp_loaded_fw = 0;
 729         if (dodnld && IS_24XX(isp)) {
 730                 const uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
 731                 uint32_t la, wi, wl;
 732
 733                 /*
 734                  * Keep loading until we run out of f/w.
 735                  */
 736                 code_org = ptr[2];      /* 1st load address is our start addr */
 737
 738                 for (;;) {
 739
 740                         isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], ptr[2]);
 741
 742                         wi = 0;
 743                         la = ptr[2];
 744                         wl = ptr[3];
 745                         while (wi < ptr[3]) {
 746                                 uint32_t *cp;
 747                                 uint32_t nw;
 748
 749                                 nw = min(wl, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) / 4);
 750                                 cp = isp->isp_rquest;
 751                                 for (i = 0; i < nw; i++)
 752                                         ISP_IOXPUT_32(isp, ptr[wi + i], &cp[i]);
 753                                 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
 754                                 MBSINIT(&mbs, MBOX_LOAD_RISC_RAM, MBLOGALL, 0);
 755                                 mbs.param[1] = la;
 756                                 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
 757                                 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
 758                                 mbs.param[4] = nw >> 16;
 759                                 mbs.param[5] = nw;
 760                                 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
 761                                 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
 762                                 mbs.param[8] = la >> 16;
 763                                 isp_prt(isp, ISP_LOGDEBUG0, "LOAD RISC RAM %u words at load address 0x%x", nw, la);
 764                                 isp_mboxcmd(isp, &mbs);
 765                                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 766                                         isp_prt(isp, ISP_LOGERR, "F/W download failed");
 767                                         return;
 768                                 }
 769                                 la += nw;
 770                                 wi += nw;
 771                                 wl -= nw;
 772                         }
 773
 774                         if (ptr[1] == 0) {
 775                                 break;
 776                         }
 777                         ptr += ptr[3];
 778                 }
 779                 isp->isp_loaded_fw = 1;
 780         } else if (dodnld && IS_23XX(isp)) {
 781                 const uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
 782                 uint16_t wi, wl, segno;
 783                 uint32_t la;
 784
 785                 la = code_org;
 786                 segno = 0;
 787
 788                 for (;;) {
 789                         uint32_t nxtaddr;
 790
 791                         isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], la);
 792
 793                         wi = 0;
 794                         wl = ptr[3];
 795
 796                         while (wi < ptr[3]) {
 797                                 uint16_t *cp;
 798                                 uint16_t nw;
 799
 800                                 nw = min(wl, min((1 << 15), ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) / 2));
 801                                 cp = isp->isp_rquest;
 802                                 for (i = 0; i < nw; i++)
 803                                         ISP_IOXPUT_16(isp, ptr[wi + i], &cp[i]);
 804                                 MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
 805                                 MBSINIT(&mbs, 0, MBLOGALL, 0);
 806                                 if (la < 0x10000) {
 807                                         mbs.param[0] = MBOX_LOAD_RISC_RAM_2100;
 808                                         mbs.param[1] = la;
 809                                         mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
 810                                         mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
 811                                         mbs.param[4] = nw;
 812                                         mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
 813                                         mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
 814                                         isp_prt(isp, ISP_LOGDEBUG1, "LOAD RISC RAM 2100 %u words at load address 0x%x\n", nw, la);
 815                                 } else {
 816                                         mbs.param[0] = MBOX_LOAD_RISC_RAM;
 817                                         mbs.param[1] = la;
 818                                         mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
 819                                         mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
 820                                         mbs.param[4] = nw;
 821                                         mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
 822                                         mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
 823                                         mbs.param[8] = la >> 16;
 824                                         isp_prt(isp, ISP_LOGDEBUG1, "LOAD RISC RAM %u words at load address 0x%x\n", nw, la);
 825                                 }
 826                                 isp_mboxcmd(isp, &mbs);
 827                                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 828                                         isp_prt(isp, ISP_LOGERR, "F/W download failed");
 829                                         return;
 830                                 }
 831                                 la += nw;
 832                                 wi += nw;
 833                                 wl -= nw;
 834                         }
 835
 836                         if (!IS_2322(isp)) {
 837                                 break;
 838                         }
 839
 840                         if (++segno == 3) {
 841                                 break;
 842                         }
 843
 844                         /*
 845                          * If we're a 2322, the firmware actually comes in
 846                          * three chunks. We loaded the first at the code_org
 847                          * address. The other two chunks, which follow right
 848                          * after each other in memory here, get loaded at
 849                          * addresses specfied at offset 0x9..0xB.
 850                          */
 851
 852                         nxtaddr = ptr[3];
 853                         ptr = &ptr[nxtaddr];
 854                         la = ptr[5] | ((ptr[4] & 0x3f) << 16);
 855                 }
 856                 isp->isp_loaded_fw = 1;
 857         } else if (dodnld) {
 858                 const uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
 859                 u_int i, wl;
 860
 861                 wl = ptr[3];
 862                 isp_prt(isp, ISP_LOGDEBUG1,
 863                     "WRITE RAM %u words at load address 0x%x", wl, code_org);
 864                 for (i = 0; i < wl; i++) {
 865                         MBSINIT(&mbs, MBOX_WRITE_RAM_WORD, MBLOGNONE, 0);
 866                         mbs.param[1] = code_org + i;
 867                         mbs.param[2] = ptr[i];
 868                         isp_mboxcmd(isp, &mbs);
 869                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 870                                 isp_prt(isp, ISP_LOGERR,
 871                                     "F/W download failed at word %d", i);
 872                                 return;
 873                         }
 874                 }
 875         } else if (IS_26XX(isp)) {
 876                 MBSINIT(&mbs, MBOX_LOAD_FLASH_FIRMWARE, MBLOGALL, 5000000);
 877                 mbs.ibitm = 0x01;
 878                 mbs.obitm = 0x07;
 879                 isp_mboxcmd(isp, &mbs);
 880                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 881                         isp_prt(isp, ISP_LOGERR, "Flash F/W load failed");
 882                         return;
 883                 }
 884         } else {
 885                 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
 886         }
 887
 888         /*
 889          * If we loaded firmware, verify its checksum
 890          */
 891         if (isp->isp_loaded_fw) {
 892                 MBSINIT(&mbs, MBOX_VERIFY_CHECKSUM, MBLOGNONE, 0);
 893                 if (IS_24XX(isp)) {
 894                         mbs.param[1] = code_org >> 16;
 895                         mbs.param[2] = code_org;
 896                 } else {
 897                         mbs.param[1] = code_org;
 898                 }
 899                 isp_mboxcmd(isp, &mbs);
 900                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 901                         isp_prt(isp, ISP_LOGERR, dcrc);
 902                         return;
 903                 }
 904         }
 905
 906         /*
 907          * Now start it rolling.
 908          *
 909          * If we didn't actually download f/w,
 910          * we still need to (re)start it.
 911          */
 912         MBSINIT(&mbs, MBOX_EXEC_FIRMWARE, MBLOGALL, 5000000);
 913         if (IS_24XX(isp)) {
 914                 mbs.param[1] = code_org >> 16;
 915                 mbs.param[2] = code_org;
 916                 if (isp->isp_loaded_fw) {
 917                         mbs.param[3] = 0;
 918                 } else {
 919                         mbs.param[3] = 1;
 920                 }
 921         } else if (IS_2322(isp)) {
 922                 mbs.param[1] = code_org;
 923                 if (isp->isp_loaded_fw) {
 924                         mbs.param[2] = 0;
 925                 } else {
 926                         mbs.param[2] = 1;
 927                 }
 928         } else {
 929                 mbs.param[1] = code_org;
 930         }
 931         isp_mboxcmd(isp, &mbs);
 932         if (IS_2322(isp) || IS_24XX(isp)) {
 933                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 934                         return;
 935                 }
 936         }
 937
 938         if (IS_SCSI(isp)) {
 939                 /*
 940                  * Set CLOCK RATE, but only if asked to.
 941                  */
 942                 if (isp->isp_clock) {
 943                         MBSINIT(&mbs, MBOX_SET_CLOCK_RATE, MBLOGALL, 0);
 944                         mbs.param[1] = isp->isp_clock;
 945                         isp_mboxcmd(isp, &mbs);
 946                         /* we will try not to care if this fails */
 947                 }
 948         }
 949
 950         /*
 951          * Ask the chip for the current firmware version.
 952          * This should prove that the new firmware is working.
 953          */
 954         MBSINIT(&mbs, MBOX_ABOUT_FIRMWARE, MBLOGALL, 0);
 955         isp_mboxcmd(isp, &mbs);
 956         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 957                 return;
 958         }
 959
 960         /*
 961          * The SBus firmware that we are using apparently does not return
 962          * major, minor, micro revisions in the mailbox registers, which
 963          * is really, really, annoying.
 964          */
 965         if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) {
 966                 if (dodnld) {
 967 #ifdef  ISP_TARGET_MODE
 968                         isp->isp_fwrev[0] = 7;
 969                         isp->isp_fwrev[1] = 55;
 970 #else
 971                         isp->isp_fwrev[0] = 1;
 972                         isp->isp_fwrev[1] = 37;
 973 #endif
 974                         isp->isp_fwrev[2] = 0;
 975                 }
 976         } else {
 977                 isp->isp_fwrev[0] = mbs.param[1];
 978                 isp->isp_fwrev[1] = mbs.param[2];
 979                 isp->isp_fwrev[2] = mbs.param[3];
 980         }
 981
 982         if (IS_FC(isp)) {
 983                 /*
 984                  * We do not believe firmware attributes for 2100 code less
 985                  * than 1.17.0, unless it's the firmware we specifically
 986                  * are loading.
 987                  *
 988                  * Note that all 22XX and later f/w is greater than 1.X.0.
 989                  */
 990                 if ((ISP_FW_OLDER_THAN(isp, 1, 17, 1))) {
 991 #ifdef  USE_SMALLER_2100_FIRMWARE
 992                         isp->isp_fwattr = ISP_FW_ATTR_SCCLUN;
 993 #else
 994                         isp->isp_fwattr = 0;
 995 #endif
 996                 } else {
 997                         isp->isp_fwattr = mbs.param[6];
 998                 }
 999                 if (IS_24XX(isp)) {
1000                         isp->isp_fwattr |= ((uint64_t) mbs.param[15]) << 16;
1001                         if (isp->isp_fwattr & ISP2400_FW_ATTR_EXTNDED) {
1002                                 isp->isp_fwattr |=
1003                                     (((uint64_t) mbs.param[16]) << 32) |
1004                                     (((uint64_t) mbs.param[17]) << 48);
1005                         }
1006                 }
1007         } else {
1008                 isp->isp_fwattr = 0;
1009         }
1010
1011         isp_prt(isp, ISP_LOGCONFIG, "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
1012             btype, isp->isp_revision, dodnld? "loaded" : "resident", isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
1013
1014         fwt = isp->isp_fwattr;
1015         if (IS_24XX(isp)) {
1016                 buf = FCPARAM(isp, 0)->isp_scanscratch;
1017                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN, "Attributes:");
1018                 if (fwt & ISP2400_FW_ATTR_CLASS2) {
1019                         fwt ^=ISP2400_FW_ATTR_CLASS2;
1020                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Class2", buf);
1021                 }
1022                 if (fwt & ISP2400_FW_ATTR_IP) {
1023                         fwt ^=ISP2400_FW_ATTR_IP;
1024                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s IP", buf);
1025                 }
1026                 if (fwt & ISP2400_FW_ATTR_MULTIID) {
1027                         fwt ^=ISP2400_FW_ATTR_MULTIID;
1028                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MultiID", buf);
1029                 }
1030                 if (fwt & ISP2400_FW_ATTR_SB2) {
1031                         fwt ^=ISP2400_FW_ATTR_SB2;
1032                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SB2", buf);
1033                 }
1034                 if (fwt & ISP2400_FW_ATTR_T10CRC) {
1035                         fwt ^=ISP2400_FW_ATTR_T10CRC;
1036                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s T10CRC", buf);
1037                 }
1038                 if (fwt & ISP2400_FW_ATTR_VI) {
1039                         fwt ^=ISP2400_FW_ATTR_VI;
1040                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI", buf);
1041                 }
1042                 if (fwt & ISP2400_FW_ATTR_MQ) {
1043                         fwt ^=ISP2400_FW_ATTR_MQ;
1044                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MQ", buf);
1045                 }
1046                 if (fwt & ISP2400_FW_ATTR_MSIX) {
1047                         fwt ^=ISP2400_FW_ATTR_MSIX;
1048                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MSIX", buf);
1049                 }
1050                 if (fwt & ISP2400_FW_ATTR_FCOE) {
1051                         fwt ^=ISP2400_FW_ATTR_FCOE;
1052                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s FCOE", buf);
1053                 }
1054                 if (fwt & ISP2400_FW_ATTR_VP0) {
1055                         fwt ^= ISP2400_FW_ATTR_VP0;
1056                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VP0_Decoupling", buf);
1057                 }
1058                 if (fwt & ISP2400_FW_ATTR_EXPFW) {
1059                         fwt ^= ISP2400_FW_ATTR_EXPFW;
1060                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (Experimental)", buf);
1061                 }
1062                 if (fwt & ISP2400_FW_ATTR_HOTFW) {
1063                         fwt ^= ISP2400_FW_ATTR_HOTFW;
1064                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s HotFW", buf);
1065                 }
1066                 fwt &= ~ISP2400_FW_ATTR_EXTNDED;
1067                 if (fwt & ISP2400_FW_ATTR_EXTVP) {
1068                         fwt ^= ISP2400_FW_ATTR_EXTVP;
1069                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ExtVP", buf);
1070                 }
1071                 if (fwt & ISP2400_FW_ATTR_VN2VN) {
1072                         fwt ^= ISP2400_FW_ATTR_VN2VN;
1073                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VN2VN", buf);
1074                 }
1075                 if (fwt & ISP2400_FW_ATTR_EXMOFF) {
1076                         fwt ^= ISP2400_FW_ATTR_EXMOFF;
1077                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s EXMOFF", buf);
1078                 }
1079                 if (fwt & ISP2400_FW_ATTR_NPMOFF) {
1080                         fwt ^= ISP2400_FW_ATTR_NPMOFF;
1081                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s NPMOFF", buf);
1082                 }
1083                 if (fwt & ISP2400_FW_ATTR_DIFCHOP) {
1084                         fwt ^= ISP2400_FW_ATTR_DIFCHOP;
1085                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s DIFCHOP", buf);
1086                 }
1087                 if (fwt & ISP2400_FW_ATTR_SRIOV) {
1088                         fwt ^= ISP2400_FW_ATTR_SRIOV;
1089                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SRIOV", buf);
1090                 }
1091                 if (fwt & ISP2400_FW_ATTR_ASICTMP) {
1092                         fwt ^= ISP2400_FW_ATTR_ASICTMP;
1093                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ASICTMP", buf);
1094                 }
1095                 if (fwt & ISP2400_FW_ATTR_ATIOMQ) {
1096                         fwt ^= ISP2400_FW_ATTR_ATIOMQ;
1097                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ATIOMQ", buf);
1098                 }
1099                 if (fwt) {
1100                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (unknown 0x%08x%08x)", buf,
1101                             (uint32_t) (fwt >> 32), (uint32_t) fwt);
1102                 }
1103                 isp_prt(isp, ISP_LOGCONFIG, "%s", buf);
1104         } else if (IS_FC(isp)) {
1105                 buf = FCPARAM(isp, 0)->isp_scanscratch;
1106                 ISP_SNPRINTF(buf, ISP_FC_SCRLEN, "Attributes:");
1107                 if (fwt & ISP_FW_ATTR_TMODE) {
1108                         fwt ^=ISP_FW_ATTR_TMODE;
1109                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s TargetMode", buf);
1110                 }
1111                 if (fwt & ISP_FW_ATTR_SCCLUN) {
1112                         fwt ^=ISP_FW_ATTR_SCCLUN;
1113                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SCC-Lun", buf);
1114                 }
1115                 if (fwt & ISP_FW_ATTR_FABRIC) {
1116                         fwt ^=ISP_FW_ATTR_FABRIC;
1117                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Fabric", buf);
1118                 }
1119                 if (fwt & ISP_FW_ATTR_CLASS2) {
1120                         fwt ^=ISP_FW_ATTR_CLASS2;
1121                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Class2", buf);
1122                 }
1123                 if (fwt & ISP_FW_ATTR_FCTAPE) {
1124                         fwt ^=ISP_FW_ATTR_FCTAPE;
1125                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s FC-Tape", buf);
1126                 }
1127                 if (fwt & ISP_FW_ATTR_IP) {
1128                         fwt ^=ISP_FW_ATTR_IP;
1129                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s IP", buf);
1130                 }
1131                 if (fwt & ISP_FW_ATTR_VI) {
1132                         fwt ^=ISP_FW_ATTR_VI;
1133                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI", buf);
1134                 }
1135                 if (fwt & ISP_FW_ATTR_VI_SOLARIS) {
1136                         fwt ^=ISP_FW_ATTR_VI_SOLARIS;
1137                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI_SOLARIS", buf);
1138                 }
1139                 if (fwt & ISP_FW_ATTR_2KLOGINS) {
1140                         fwt ^=ISP_FW_ATTR_2KLOGINS;
1141                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s 2K-Login", buf);
1142                 }
1143                 if (fwt != 0) {
1144                         ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (unknown 0x%08x%08x)", buf,
1145                             (uint32_t) (fwt >> 32), (uint32_t) fwt);
1146                 }
1147                 isp_prt(isp, ISP_LOGCONFIG, "%s", buf);
1148         }
1149
1150         if (IS_24XX(isp)) {
1151                 MBSINIT(&mbs, MBOX_GET_RESOURCE_COUNT, MBLOGALL, 0);
1152                 isp_mboxcmd(isp, &mbs);
1153                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1154                         return;
1155                 }
1156                 isp->isp_maxcmds = mbs.param[3];
1157         } else {
1158                 MBSINIT(&mbs, MBOX_GET_FIRMWARE_STATUS, MBLOGALL, 0);
1159                 isp_mboxcmd(isp, &mbs);
1160                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1161                         return;
1162                 }
1163                 isp->isp_maxcmds = mbs.param[2];
1164         }
1165         isp_prt(isp, ISP_LOGCONFIG, "%d max I/O command limit set", isp->isp_maxcmds);
1166
1167         /*
1168          * If we don't have Multi-ID f/w loaded, we need to restrict channels to one.
1169          * Only make this check for non-SCSI cards (I'm not sure firmware attributes
1170          * work for them).
1171          */
1172         if (IS_FC(isp) && isp->isp_nchan > 1) {
1173                 if (!ISP_CAP_MULTI_ID(isp)) {
1174                         isp_prt(isp, ISP_LOGWARN, "non-MULTIID f/w loaded, "
1175                             "only can enable 1 of %d channels", isp->isp_nchan);
1176                         isp->isp_nchan = 1;
1177                 } else if (!ISP_CAP_VP0(isp)) {
1178                         isp_prt(isp, ISP_LOGWARN, "We can not use MULTIID "
1179                             "feature properly without VP0_Decoupling");
1180                         isp->isp_nchan = 1;
1181                 }
1182         }
1183
1184         /*
1185          * Final DMA setup after we got isp_maxcmds.
1186          */
1187         if (ISP_MBOXDMASETUP(isp) != 0) {
1188                 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
1189                 return;
1190         }
1191
1192         /*
1193          * Setup interrupts.
1194          */
1195         if (ISP_IRQSETUP(isp) != 0) {
1196                 isp_prt(isp, ISP_LOGERR, "Cannot setup IRQ");
1197                 return;
1198         }
1199         ISP_ENABLE_INTS(isp);
1200
1201         if (IS_FC(isp)) {
1202                 for (i = 0; i < isp->isp_nchan; i++)
1203                         isp_change_fw_state(isp, i, FW_CONFIG_WAIT);
1204         }
1205
1206         isp->isp_state = ISP_RESETSTATE;
1207
1208         /*
1209          * Okay- now that we have new firmware running, we now (re)set our
1210          * notion of how many luns we support. This is somewhat tricky because
1211          * if we haven't loaded firmware, we sometimes do not have an easy way
1212          * of knowing how many luns we support.
1213          *
1214          * Expanded lun firmware gives you 32 luns for SCSI cards and
1215          * unlimited luns for Fibre Channel cards.
1216          *
1217          * It turns out that even for QLogic 2100s with ROM 1.10 and above
1218          * we do get a firmware attributes word returned in mailbox register 6.
1219          *
1220          * Because the lun is in a different position in the Request Queue
1221          * Entry structure for Fibre Channel with expanded lun firmware, we
1222          * can only support one lun (lun zero) when we don't know what kind
1223          * of firmware we're running.
1224          */
1225         if (IS_SCSI(isp)) {
1226                 if (dodnld) {
1227                         if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
1228                                 isp->isp_maxluns = 32;
1229                         } else {
1230                                 isp->isp_maxluns = 8;
1231                         }
1232                 } else {
1233                         isp->isp_maxluns = 8;
1234                 }
1235         } else {
1236                 if (ISP_CAP_SCCFW(isp)) {
1237                         isp->isp_maxluns = 0;   /* No limit -- 2/8 bytes */
1238                 } else {
1239                         isp->isp_maxluns = 16;
1240                 }
1241         }
1242
1243         /*
1244          * We get some default values established. As a side
1245          * effect, NVRAM is read here (unless overriden by
1246          * a configuration flag).
1247          */
1248         if (do_load_defaults) {
1249                 if (IS_SCSI(isp)) {
1250                         isp_setdfltsdparm(isp);
1251                 } else {
1252                         for (i = 0; i < isp->isp_nchan; i++) {
1253                                 isp_setdfltfcparm(isp, i);
1254                         }
1255                 }
1256         }
1257 }
1258
1259 /*
1260  * Clean firmware shutdown.
1261  */
1262 static int
1263 isp_stop(ispsoftc_t *isp)
1264 {
1265         mbreg_t mbs;
1266
1267         isp->isp_state = ISP_NILSTATE;
1268         MBSINIT(&mbs, MBOX_STOP_FIRMWARE, MBLOGALL, 500000);
1269         mbs.param[1] = 0;
1270         mbs.param[2] = 0;
1271         mbs.param[3] = 0;
1272         mbs.param[4] = 0;
1273         mbs.param[5] = 0;
1274         mbs.param[6] = 0;
1275         mbs.param[7] = 0;
1276         mbs.param[8] = 0;
1277         isp_mboxcmd(isp, &mbs);
1278         return (mbs.param[0] == MBOX_COMMAND_COMPLETE ? 0 : mbs.param[0]);
1279 }
1280
1281 /*
1282  * Hardware shutdown.
1283  */
1284 void
1285 isp_shutdown(ispsoftc_t *isp)
1286 {
1287
1288         if (isp->isp_state >= ISP_RESETSTATE)
1289                 isp_stop(isp);
1290         ISP_DISABLE_INTS(isp);
1291         if (IS_FC(isp)) {
1292                 if (IS_24XX(isp)) {
1293                         ISP_WRITE(isp, BIU2400_ICR, 0);
1294                         ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
1295                 } else {
1296                         ISP_WRITE(isp, BIU_ICR, 0);
1297                         ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
1298                         ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
1299                         ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
1300                         ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
1301                         ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
1302                         ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
1303                 }
1304         } else {
1305                 ISP_WRITE(isp, BIU_ICR, 0);
1306                 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
1307         }
1308 }
1309
1310 /*
1311  * Initialize Parameters of Hardware to a known state.
1312  *
1313  * Locks are held before coming here.
1314  */
1315 void
1316 isp_init(ispsoftc_t *isp)
1317 {
1318         if (IS_FC(isp)) {
1319                 if (IS_24XX(isp)) {
1320                         isp_fibre_init_2400(isp);
1321                 } else {
1322                         isp_fibre_init(isp);
1323                 }
1324         } else {
1325                 isp_scsi_init(isp);
1326         }
1327 }
1328
1329 static void
1330 isp_scsi_init(ispsoftc_t *isp)
1331 {
1332         sdparam *sdp_chan0, *sdp_chan1;
1333         mbreg_t mbs;
1334
1335         isp->isp_state = ISP_INITSTATE;
1336
1337         sdp_chan0 = SDPARAM(isp, 0);
1338         sdp_chan1 = sdp_chan0;
1339         if (IS_DUALBUS(isp)) {
1340                 sdp_chan1 = SDPARAM(isp, 1);
1341         }
1342
1343         /* First do overall per-card settings. */
1344
1345         /*
1346          * If we have fast memory timing enabled, turn it on.
1347          */
1348         if (sdp_chan0->isp_fast_mttr) {
1349                 ISP_WRITE(isp, RISC_MTR, 0x1313);
1350         }
1351
1352         /*
1353          * Set Retry Delay and Count.
1354          * You set both channels at the same time.
1355          */
1356         MBSINIT(&mbs, MBOX_SET_RETRY_COUNT, MBLOGALL, 0);
1357         mbs.param[1] = sdp_chan0->isp_retry_count;
1358         mbs.param[2] = sdp_chan0->isp_retry_delay;
1359         mbs.param[6] = sdp_chan1->isp_retry_count;
1360         mbs.param[7] = sdp_chan1->isp_retry_delay;
1361         isp_mboxcmd(isp, &mbs);
1362         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1363                 return;
1364         }
1365
1366         /*
1367          * Set ASYNC DATA SETUP time. This is very important.
1368          */
1369         MBSINIT(&mbs, MBOX_SET_ASYNC_DATA_SETUP_TIME, MBLOGALL, 0);
1370         mbs.param[1] = sdp_chan0->isp_async_data_setup;
1371         mbs.param[2] = sdp_chan1->isp_async_data_setup;
1372         isp_mboxcmd(isp, &mbs);
1373         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1374                 return;
1375         }
1376
1377         /*
1378          * Set ACTIVE Negation State.
1379          */
1380         MBSINIT(&mbs, MBOX_SET_ACT_NEG_STATE, MBLOGNONE, 0);
1381         mbs.param[1] =
1382             (sdp_chan0->isp_req_ack_active_neg << 4) |
1383             (sdp_chan0->isp_data_line_active_neg << 5);
1384         mbs.param[2] =
1385             (sdp_chan1->isp_req_ack_active_neg << 4) |
1386             (sdp_chan1->isp_data_line_active_neg << 5);
1387         isp_mboxcmd(isp, &mbs);
1388         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1389                 isp_prt(isp, ISP_LOGERR,
1390                     "failed to set active negation state (%d,%d), (%d,%d)",
1391                     sdp_chan0->isp_req_ack_active_neg,
1392                     sdp_chan0->isp_data_line_active_neg,
1393                     sdp_chan1->isp_req_ack_active_neg,
1394                     sdp_chan1->isp_data_line_active_neg);
1395                 /*
1396                  * But don't return.
1397                  */
1398         }
1399
1400         /*
1401          * Set the Tag Aging limit
1402          */
1403         MBSINIT(&mbs, MBOX_SET_TAG_AGE_LIMIT, MBLOGALL, 0);
1404         mbs.param[1] = sdp_chan0->isp_tag_aging;
1405         mbs.param[2] = sdp_chan1->isp_tag_aging;
1406         isp_mboxcmd(isp, &mbs);
1407         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1408                 isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
1409                     sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
1410                 return;
1411         }
1412
1413         /*
1414          * Set selection timeout.
1415          */
1416         MBSINIT(&mbs, MBOX_SET_SELECT_TIMEOUT, MBLOGALL, 0);
1417         mbs.param[1] = sdp_chan0->isp_selection_timeout;
1418         mbs.param[2] = sdp_chan1->isp_selection_timeout;
1419         isp_mboxcmd(isp, &mbs);
1420         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1421                 return;
1422         }
1423
1424         /* now do per-channel settings */
1425         isp_scsi_channel_init(isp, 0);
1426         if (IS_DUALBUS(isp))
1427                 isp_scsi_channel_init(isp, 1);
1428
1429         /*
1430          * Now enable request/response queues
1431          */
1432
1433         if (IS_ULTRA2(isp) || IS_1240(isp)) {
1434                 MBSINIT(&mbs, MBOX_INIT_RES_QUEUE_A64, MBLOGALL, 0);
1435                 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1436                 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1437                 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1438                 mbs.param[4] = 0;
1439                 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1440                 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1441                 isp_mboxcmd(isp, &mbs);
1442                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1443                         return;
1444                 }
1445                 isp->isp_residx = isp->isp_resodx = mbs.param[5];
1446
1447                 MBSINIT(&mbs, MBOX_INIT_REQ_QUEUE_A64, MBLOGALL, 0);
1448                 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1449                 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1450                 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1451                 mbs.param[5] = 0;
1452                 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1453                 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1454                 isp_mboxcmd(isp, &mbs);
1455                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1456                         return;
1457                 }
1458                 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1459         } else {
1460                 MBSINIT(&mbs, MBOX_INIT_RES_QUEUE, MBLOGALL, 0);
1461                 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1462                 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1463                 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1464                 mbs.param[4] = 0;
1465                 isp_mboxcmd(isp, &mbs);
1466                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1467                         return;
1468                 }
1469                 isp->isp_residx = isp->isp_resodx = mbs.param[5];
1470
1471                 MBSINIT(&mbs, MBOX_INIT_REQ_QUEUE, MBLOGALL, 0);
1472                 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1473                 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1474                 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1475                 mbs.param[5] = 0;
1476                 isp_mboxcmd(isp, &mbs);
1477                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1478                         return;
1479                 }
1480                 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1481         }
1482
1483         /*
1484          * Turn on LVD transitions for ULTRA2 or better and other features
1485          *
1486          * Now that we have 32 bit handles, don't do any fast posting
1487          * any more. For Ultra2/Ultra3 cards, we can turn on 32 bit RIO
1488          * operation or use fast posting. To be conservative, we'll only
1489          * do this for Ultra3 cards now because the other cards are so
1490          * rare for this author to find and test with.
1491          */
1492
1493         MBSINIT(&mbs, MBOX_SET_FW_FEATURES, MBLOGALL, 0);
1494         if (IS_ULTRA2(isp))
1495                 mbs.param[1] |= FW_FEATURE_LVD_NOTIFY;
1496 #ifdef  ISP_NO_RIO
1497         if (IS_ULTRA3(isp))
1498                 mbs.param[1] |= FW_FEATURE_FAST_POST;
1499 #else
1500         if (IS_ULTRA3(isp))
1501                 mbs.param[1] |= FW_FEATURE_RIO_32BIT;
1502 #endif
1503         if (mbs.param[1] != 0) {
1504                 uint16_t sfeat = mbs.param[1];
1505                 isp_mboxcmd(isp, &mbs);
1506                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1507                         isp_prt(isp, ISP_LOGINFO,
1508                             "Enabled FW features (0x%x)", sfeat);
1509                 }
1510         }
1511
1512         isp->isp_state = ISP_RUNSTATE;
1513 }
1514
1515 static void
1516 isp_scsi_channel_init(ispsoftc_t *isp, int chan)
1517 {
1518         sdparam *sdp;
1519         mbreg_t mbs;
1520         int tgt;
1521
1522         sdp = SDPARAM(isp, chan);
1523
1524         /*
1525          * Set (possibly new) Initiator ID.
1526          */
1527         MBSINIT(&mbs, MBOX_SET_INIT_SCSI_ID, MBLOGALL, 0);
1528         mbs.param[1] = (chan << 7) | sdp->isp_initiator_id;
1529         isp_mboxcmd(isp, &mbs);
1530         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1531                 return;
1532         }
1533         isp_prt(isp, ISP_LOGINFO, "Chan %d Initiator ID is %d",
1534             chan, sdp->isp_initiator_id);
1535
1536
1537         /*
1538          * Set current per-target parameters to an initial safe minimum.
1539          */
1540         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1541                 int lun;
1542                 uint16_t sdf;
1543
1544                 if (sdp->isp_devparam[tgt].dev_enable == 0) {
1545                         continue;
1546                 }
1547 #ifndef ISP_TARGET_MODE
1548                 sdf = sdp->isp_devparam[tgt].goal_flags;
1549                 sdf &= DPARM_SAFE_DFLT;
1550                 /*
1551                  * It is not quite clear when this changed over so that
1552                  * we could force narrow and async for 1000/1020 cards,
1553                  * but assume that this is only the case for loaded
1554                  * firmware.
1555                  */
1556                 if (isp->isp_loaded_fw) {
1557                         sdf |= DPARM_NARROW | DPARM_ASYNC;
1558                 }
1559 #else
1560                 /*
1561                  * The !$*!)$!$)* f/w uses the same index into some
1562                  * internal table to decide how to respond to negotiations,
1563                  * so if we've said "let's be safe" for ID X, and ID X
1564                  * selects *us*, the negotiations will back to 'safe'
1565                  * (as in narrow/async). What the f/w *should* do is
1566                  * use the initiator id settings to decide how to respond.
1567                  */
1568                 sdp->isp_devparam[tgt].goal_flags = sdf = DPARM_DEFAULT;
1569 #endif
1570                 MBSINIT(&mbs, MBOX_SET_TARGET_PARAMS, MBLOGNONE, 0);
1571                 mbs.param[1] = (chan << 15) | (tgt << 8);
1572                 mbs.param[2] = sdf;
1573                 if ((sdf & DPARM_SYNC) == 0) {
1574                         mbs.param[3] = 0;
1575                 } else {
1576                         mbs.param[3] =
1577                             (sdp->isp_devparam[tgt].goal_offset << 8) |
1578                             (sdp->isp_devparam[tgt].goal_period);
1579                 }
1580                 isp_prt(isp, ISP_LOGDEBUG0, "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
1581                     chan, tgt, mbs.param[2], mbs.param[3] >> 8, mbs.param[3] & 0xff);
1582                 isp_mboxcmd(isp, &mbs);
1583                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1584                         sdf = DPARM_SAFE_DFLT;
1585                         MBSINIT(&mbs, MBOX_SET_TARGET_PARAMS, MBLOGALL, 0);
1586                         mbs.param[1] = (tgt << 8) | (chan << 15);
1587                         mbs.param[2] = sdf;
1588                         mbs.param[3] = 0;
1589                         isp_mboxcmd(isp, &mbs);
1590                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1591                                 continue;
1592                         }
1593                 }
1594
1595                 /*
1596                  * We don't update any information directly from the f/w
1597                  * because we need to run at least one command to cause a
1598                  * new state to be latched up. So, we just assume that we
1599                  * converge to the values we just had set.
1600                  *
1601                  * Ensure that we don't believe tagged queuing is enabled yet.
1602                  * It turns out that sometimes the ISP just ignores our
1603                  * attempts to set parameters for devices that it hasn't
1604                  * seen yet.
1605                  */
1606                 sdp->isp_devparam[tgt].actv_flags = sdf & ~DPARM_TQING;
1607                 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1608                         MBSINIT(&mbs, MBOX_SET_DEV_QUEUE_PARAMS, MBLOGALL, 0);
1609                         mbs.param[1] = (chan << 15) | (tgt << 8) | lun;
1610                         mbs.param[2] = sdp->isp_max_queue_depth;
1611                         mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
1612                         isp_mboxcmd(isp, &mbs);
1613                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1614                                 break;
1615                         }
1616                 }
1617         }
1618         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1619                 if (sdp->isp_devparam[tgt].dev_refresh) {
1620                         sdp->sendmarker = 1;
1621                         sdp->update = 1;
1622                         break;
1623                 }
1624         }
1625 }
1626
1627 /*
1628  * Fibre Channel specific initialization.
1629  */
1630 static void
1631 isp_fibre_init(ispsoftc_t *isp)
1632 {
1633         fcparam *fcp;
1634         isp_icb_t local, *icbp = &local;
1635         mbreg_t mbs;
1636         int ownloopid;
1637
1638         /*
1639          * We only support one channel on non-24XX cards
1640          */
1641         fcp = FCPARAM(isp, 0);
1642         if (fcp->role == ISP_ROLE_NONE)
1643                 return;
1644
1645         isp->isp_state = ISP_INITSTATE;
1646         ISP_MEMZERO(icbp, sizeof (*icbp));
1647         icbp->icb_version = ICB_VERSION1;
1648         icbp->icb_fwoptions = fcp->isp_fwoptions;
1649
1650         /*
1651          * Firmware Options are either retrieved from NVRAM or
1652          * are patched elsewhere. We check them for sanity here
1653          * and make changes based on board revision, but otherwise
1654          * let others decide policy.
1655          */
1656
1657         /*
1658          * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
1659          */
1660         if (IS_2100(isp) && isp->isp_revision < 5) {
1661                 icbp->icb_fwoptions &= ~ICBOPT_FAIRNESS;
1662         }
1663
1664         /*
1665          * We have to use FULL LOGIN even though it resets the loop too much
1666          * because otherwise port database entries don't get updated after
1667          * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
1668          */
1669         if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1670                 icbp->icb_fwoptions |= ICBOPT_FULL_LOGIN;
1671         }
1672
1673         /*
1674          * Insist on Port Database Update Async notifications
1675          */
1676         icbp->icb_fwoptions |= ICBOPT_PDBCHANGE_AE;
1677
1678         /*
1679          * Make sure that target role reflects into fwoptions.
1680          */
1681         if (fcp->role & ISP_ROLE_TARGET) {
1682                 icbp->icb_fwoptions |= ICBOPT_TGT_ENABLE;
1683         } else {
1684                 icbp->icb_fwoptions &= ~ICBOPT_TGT_ENABLE;
1685         }
1686
1687         /*
1688          * For some reason my 2200 does not generate ATIOs in target mode
1689          * if initiator is disabled.  Extra logins are better then target
1690          * not working at all.
1691          */
1692         if ((fcp->role & ISP_ROLE_INITIATOR) || IS_2100(isp) || IS_2200(isp)) {
1693                 icbp->icb_fwoptions &= ~ICBOPT_INI_DISABLE;
1694         } else {
1695                 icbp->icb_fwoptions |= ICBOPT_INI_DISABLE;
1696         }
1697
1698         icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
1699         if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1700                 isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
1701                 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1702         }
1703         icbp->icb_maxalloc = fcp->isp_maxalloc;
1704         if (icbp->icb_maxalloc < 1) {
1705                 isp_prt(isp, ISP_LOGERR, "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1706                 icbp->icb_maxalloc = 16;
1707         }
1708         icbp->icb_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
1709         if (icbp->icb_execthrottle < 1) {
1710                 isp_prt(isp, ISP_LOGERR, "bad execution throttle of %d- using %d", DEFAULT_EXEC_THROTTLE(isp), ICB_DFLT_THROTTLE);
1711                 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1712         }
1713         icbp->icb_retry_delay = fcp->isp_retry_delay;
1714         icbp->icb_retry_count = fcp->isp_retry_count;
1715         icbp->icb_hardaddr = fcp->isp_loopid;
1716         ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
1717         if (icbp->icb_hardaddr >= LOCAL_LOOP_LIM) {
1718                 icbp->icb_hardaddr = 0;
1719                 ownloopid = 0;
1720         }
1721
1722         /*
1723          * Our life seems so much better with 2200s and later with
1724          * the latest f/w if we set Hard Address.
1725          */
1726         if (ownloopid || ISP_FW_NEWER_THAN(isp, 2, 2, 5)) {
1727                 icbp->icb_fwoptions |= ICBOPT_HARD_ADDRESS;
1728         }
1729
1730         /*
1731          * Right now we just set extended options to prefer point-to-point
1732          * over loop based upon some soft config options.
1733          *
1734          * NB: for the 2300, ICBOPT_EXTENDED is required.
1735          */
1736         if (IS_2100(isp)) {
1737                 /*
1738                  * We can't have Fast Posting any more- we now
1739                  * have 32 bit handles.
1740                  */
1741                 icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1742         } else if (IS_2200(isp) || IS_23XX(isp)) {
1743                 icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1744
1745                 icbp->icb_xfwoptions = fcp->isp_xfwoptions;
1746
1747                 if (ISP_CAP_FCTAPE(isp)) {
1748                         if (isp->isp_confopts & ISP_CFG_NOFCTAPE)
1749                                 icbp->icb_xfwoptions &= ~ICBXOPT_FCTAPE;
1750
1751                         if (isp->isp_confopts & ISP_CFG_FCTAPE)
1752                                 icbp->icb_xfwoptions |= ICBXOPT_FCTAPE;
1753
1754                         if (icbp->icb_xfwoptions & ICBXOPT_FCTAPE) {
1755                                 icbp->icb_fwoptions &= ~ICBOPT_FULL_LOGIN;      /* per documents */
1756                                 icbp->icb_xfwoptions |= ICBXOPT_FCTAPE_CCQ|ICBXOPT_FCTAPE_CONFIRM;
1757                                 FCPARAM(isp, 0)->fctape_enabled = 1;
1758                         } else {
1759                                 FCPARAM(isp, 0)->fctape_enabled = 0;
1760                         }
1761                 } else {
1762                         icbp->icb_xfwoptions &= ~ICBXOPT_FCTAPE;
1763                         FCPARAM(isp, 0)->fctape_enabled = 0;
1764                 }
1765
1766                 /*
1767                  * Prefer or force Point-To-Point instead Loop?
1768                  */
1769                 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
1770                 case ISP_CFG_LPORT_ONLY:
1771                         icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1772                         icbp->icb_xfwoptions |= ICBXOPT_LOOP_ONLY;
1773                         break;
1774                 case ISP_CFG_NPORT_ONLY:
1775                         icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1776                         icbp->icb_xfwoptions |= ICBXOPT_PTP_ONLY;
1777                         break;
1778                 case ISP_CFG_LPORT:
1779                         icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1780                         icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1781                         break;
1782                 case ISP_CFG_NPORT:
1783                         icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1784                         icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
1785                         break;
1786                 default:
1787                         /* Let NVRAM settings define it if they are sane */
1788                         switch (icbp->icb_xfwoptions & ICBXOPT_TOPO_MASK) {
1789                         case ICBXOPT_PTP_2_LOOP:
1790                         case ICBXOPT_PTP_ONLY:
1791                         case ICBXOPT_LOOP_ONLY:
1792                         case ICBXOPT_LOOP_2_PTP:
1793                                 break;
1794                         default:
1795                                 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1796                                 icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1797                         }
1798                         break;
1799                 }
1800                 if (IS_2200(isp)) {
1801                         /*
1802                          * We can't have Fast Posting any more- we now
1803                          * have 32 bit handles.
1804                          *
1805                          * RIO seemed to have to much breakage.
1806                          *
1807                          * Just opt for safety.
1808                          */
1809                         icbp->icb_xfwoptions &= ~ICBXOPT_RIO_16BIT;
1810                         icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1811                 } else {
1812                         /*
1813                          * QLogic recommends that FAST Posting be turned
1814                          * off for 23XX cards and instead allow the HBA
1815                          * to write response queue entries and interrupt
1816                          * after a delay (ZIO).
1817                          */
1818                         icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1819                         if ((fcp->isp_xfwoptions & ICBXOPT_TIMER_MASK) == ICBXOPT_ZIO) {
1820                                 icbp->icb_xfwoptions |= ICBXOPT_ZIO;
1821                                 icbp->icb_idelaytimer = 10;
1822                         }
1823                         icbp->icb_zfwoptions = fcp->isp_zfwoptions;
1824                         if (isp->isp_confopts & ISP_CFG_1GB) {
1825                                 icbp->icb_zfwoptions &= ~ICBZOPT_RATE_MASK;
1826                                 icbp->icb_zfwoptions |= ICBZOPT_RATE_1GB;
1827                         } else if (isp->isp_confopts & ISP_CFG_2GB) {
1828                                 icbp->icb_zfwoptions &= ~ICBZOPT_RATE_MASK;
1829                                 icbp->icb_zfwoptions |= ICBZOPT_RATE_2GB;
1830                         } else {
1831                                 switch (icbp->icb_zfwoptions & ICBZOPT_RATE_MASK) {
1832                                 case ICBZOPT_RATE_1GB:
1833                                 case ICBZOPT_RATE_2GB:
1834                                 case ICBZOPT_RATE_AUTO:
1835                                         break;
1836                                 default:
1837                                         icbp->icb_zfwoptions &= ~ICBZOPT_RATE_MASK;
1838                                         icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO;
1839                                         break;
1840                                 }
1841                         }
1842                 }
1843         }
1844
1845
1846         /*
1847          * For 22XX > 2.1.26 && 23XX, set some options.
1848          */
1849         if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1850                 MBSINIT(&mbs, MBOX_SET_FIRMWARE_OPTIONS, MBLOGALL, 0);
1851                 mbs.param[1] = IFCOPT1_DISF7SWTCH|IFCOPT1_LIPASYNC|IFCOPT1_LIPF8;
1852                 mbs.param[2] = 0;
1853                 mbs.param[3] = 0;
1854                 if (ISP_FW_NEWER_THAN(isp, 3, 16, 0)) {
1855                         mbs.param[1] |= IFCOPT1_EQFQASYNC|IFCOPT1_CTIO_RETRY;
1856                         if (fcp->role & ISP_ROLE_TARGET) {
1857                                 if (ISP_FW_NEWER_THAN(isp, 3, 25, 0)) {
1858                                         mbs.param[1] |= IFCOPT1_ENAPURE;
1859                                 }
1860                                 mbs.param[3] = IFCOPT3_NOPRLI;
1861                         }
1862                 }
1863                 isp_mboxcmd(isp, &mbs);
1864                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1865                         return;
1866                 }
1867         }
1868         icbp->icb_logintime = ICB_LOGIN_TOV;
1869
1870 #ifdef  ISP_TARGET_MODE
1871         if (icbp->icb_fwoptions & ICBOPT_TGT_ENABLE) {
1872                 icbp->icb_lunenables = 0xffff;
1873                 icbp->icb_ccnt = 0xff;
1874                 icbp->icb_icnt = 0xff;
1875                 icbp->icb_lunetimeout = ICB_LUN_ENABLE_TOV;
1876         }
1877 #endif
1878         if (fcp->isp_wwnn && fcp->isp_wwpn) {
1879                 icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
1880                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwnn);
1881                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
1882                 isp_prt(isp, ISP_LOGDEBUG1,
1883                     "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1884                     ((uint32_t) (fcp->isp_wwnn >> 32)),
1885                     ((uint32_t) (fcp->isp_wwnn)),
1886                     ((uint32_t) (fcp->isp_wwpn >> 32)),
1887                     ((uint32_t) (fcp->isp_wwpn)));
1888         } else if (fcp->isp_wwpn) {
1889                 icbp->icb_fwoptions &= ~ICBOPT_BOTH_WWNS;
1890                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
1891                 isp_prt(isp, ISP_LOGDEBUG1,
1892                     "Setting ICB Port 0x%08x%08x",
1893                     ((uint32_t) (fcp->isp_wwpn >> 32)),
1894                     ((uint32_t) (fcp->isp_wwpn)));
1895         } else {
1896                 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1897                 return;
1898         }
1899         icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1900         if (icbp->icb_rqstqlen < 1) {
1901                 isp_prt(isp, ISP_LOGERR, "bad request queue length");
1902         }
1903         icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1904         if (icbp->icb_rsltqlen < 1) {
1905                 isp_prt(isp, ISP_LOGERR, "bad result queue length");
1906         }
1907         icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1908         icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1909         icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1910         icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1911         icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1912         icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1913         icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1914         icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1915
1916         if (FC_SCRATCH_ACQUIRE(isp, 0)) {
1917                 isp_prt(isp, ISP_LOGERR, sacq);
1918                 return;
1919         }
1920         isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
1921             icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions);
1922
1923         isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
1924         if (isp->isp_dblev & ISP_LOGDEBUG1) {
1925                 isp_print_bytes(isp, "isp_fibre_init",
1926                     sizeof(*icbp), fcp->isp_scratch);
1927         }
1928
1929         /*
1930          * Init the firmware
1931          */
1932         MBSINIT(&mbs, MBOX_INIT_FIRMWARE, MBLOGALL, 30000000);
1933         mbs.param[1] = 0;
1934         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1935         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1936         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1937         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1938         isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %p (%08x%08x)",
1939             fcp->isp_scratch, (uint32_t) ((uint64_t)fcp->isp_scdma >> 32),
1940             (uint32_t) fcp->isp_scdma);
1941         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
1942         isp_mboxcmd(isp, &mbs);
1943         FC_SCRATCH_RELEASE(isp, 0);
1944         if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
1945                 return;
1946         isp->isp_reqidx = 0;
1947         isp->isp_reqodx = 0;
1948         isp->isp_residx = 0;
1949         isp->isp_resodx = 0;
1950
1951         /*
1952          * Whatever happens, we're now committed to being here.
1953          */
1954         isp->isp_state = ISP_RUNSTATE;
1955 }
1956
1957 static void
1958 isp_fibre_init_2400(ispsoftc_t *isp)
1959 {
1960         fcparam *fcp;
1961         isp_icb_2400_t local, *icbp = &local;
1962         mbreg_t mbs;
1963         int chan;
1964         int ownloopid = 0;
1965
1966         /*
1967          * Check to see whether all channels have *some* kind of role
1968          */
1969         for (chan = 0; chan < isp->isp_nchan; chan++) {
1970                 fcp = FCPARAM(isp, chan);
1971                 if (fcp->role != ISP_ROLE_NONE) {
1972                         break;
1973                 }
1974         }
1975         if (chan == isp->isp_nchan) {
1976                 isp_prt(isp, ISP_LOG_WARN1, "all %d channels with role 'none'", chan);
1977                 return;
1978         }
1979
1980         isp->isp_state = ISP_INITSTATE;
1981
1982         /*
1983          * Start with channel 0.
1984          */
1985         fcp = FCPARAM(isp, 0);
1986
1987         /*
1988          * Turn on LIP F8 async event (1)
1989          */
1990         MBSINIT(&mbs, MBOX_SET_FIRMWARE_OPTIONS, MBLOGALL, 0);
1991         mbs.param[1] = 1;
1992         isp_mboxcmd(isp, &mbs);
1993         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1994                 return;
1995         }
1996
1997         ISP_MEMZERO(icbp, sizeof (*icbp));
1998         icbp->icb_fwoptions1 = fcp->isp_fwoptions;
1999         icbp->icb_fwoptions2 = fcp->isp_xfwoptions;
2000         icbp->icb_fwoptions3 = fcp->isp_zfwoptions;
2001         if (isp->isp_nchan > 1 && ISP_CAP_VP0(isp)) {
2002                 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_INI_DISABLE;
2003                 icbp->icb_fwoptions1 |= ICB2400_OPT1_TGT_ENABLE;
2004         } else {
2005                 if (fcp->role & ISP_ROLE_TARGET)
2006                         icbp->icb_fwoptions1 |= ICB2400_OPT1_TGT_ENABLE;
2007                 else
2008                         icbp->icb_fwoptions1 &= ~ICB2400_OPT1_TGT_ENABLE;
2009                 if (fcp->role & ISP_ROLE_INITIATOR)
2010                         icbp->icb_fwoptions1 &= ~ICB2400_OPT1_INI_DISABLE;
2011                 else
2012                         icbp->icb_fwoptions1 |= ICB2400_OPT1_INI_DISABLE;
2013         }
2014
2015         icbp->icb_version = ICB_VERSION1;
2016         icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
2017         if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
2018                 isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
2019                 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
2020         }
2021
2022         icbp->icb_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
2023         if (icbp->icb_execthrottle < 1) {
2024                 isp_prt(isp, ISP_LOGERR, "bad execution throttle of %d- using %d", DEFAULT_EXEC_THROTTLE(isp), ICB_DFLT_THROTTLE);
2025                 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
2026         }
2027
2028         /*
2029          * Set target exchange count. Take half if we are supporting both roles.
2030          */
2031         if (icbp->icb_fwoptions1 & ICB2400_OPT1_TGT_ENABLE) {
2032                 icbp->icb_xchgcnt = isp->isp_maxcmds;
2033                 if ((icbp->icb_fwoptions1 & ICB2400_OPT1_INI_DISABLE) == 0)
2034                         icbp->icb_xchgcnt >>= 1;
2035         }
2036
2037
2038         ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
2039         icbp->icb_hardaddr = fcp->isp_loopid;
2040         if (icbp->icb_hardaddr >= LOCAL_LOOP_LIM) {
2041                 icbp->icb_hardaddr = 0;
2042                 ownloopid = 0;
2043         }
2044
2045         if (ownloopid)
2046                 icbp->icb_fwoptions1 |= ICB2400_OPT1_HARD_ADDRESS;
2047
2048         if (isp->isp_confopts & ISP_CFG_NOFCTAPE) {
2049                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_FCTAPE;
2050         }
2051         if (isp->isp_confopts & ISP_CFG_FCTAPE) {
2052                 icbp->icb_fwoptions2 |= ICB2400_OPT2_FCTAPE;
2053         }
2054
2055         for (chan = 0; chan < isp->isp_nchan; chan++) {
2056                 if (icbp->icb_fwoptions2 & ICB2400_OPT2_FCTAPE)
2057                         FCPARAM(isp, chan)->fctape_enabled = 1;
2058                 else
2059                         FCPARAM(isp, chan)->fctape_enabled = 0;
2060         }
2061
2062         switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
2063         case ISP_CFG_LPORT_ONLY:
2064                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2065                 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_ONLY;
2066                 break;
2067         case ISP_CFG_NPORT_ONLY:
2068                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2069                 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_ONLY;
2070                 break;
2071         case ISP_CFG_NPORT:
2072                 /* ISP_CFG_PTP_2_LOOP not available in 24XX/25XX */
2073         case ISP_CFG_LPORT:
2074                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2075                 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
2076                 break;
2077         default:
2078                 /* Let NVRAM settings define it if they are sane */
2079                 switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TOPO_MASK) {
2080                 case ICB2400_OPT2_LOOP_ONLY:
2081                 case ICB2400_OPT2_PTP_ONLY:
2082                 case ICB2400_OPT2_LOOP_2_PTP:
2083                         break;
2084                 default:
2085                         icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2086                         icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
2087                 }
2088                 break;
2089         }
2090
2091         switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK) {
2092         case ICB2400_OPT2_ZIO:
2093         case ICB2400_OPT2_ZIO1:
2094                 icbp->icb_idelaytimer = 0;
2095                 break;
2096         case 0:
2097                 break;
2098         default:
2099                 isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field", icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
2100                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TIMER_MASK;
2101                 break;
2102         }
2103
2104         if (IS_26XX(isp)) {
2105                 /* Use handshake to reduce global lock congestion. */
2106                 icbp->icb_fwoptions2 |= ICB2400_OPT2_ENA_IHR;
2107                 icbp->icb_fwoptions2 |= ICB2400_OPT2_ENA_IHA;
2108         }
2109
2110         if ((icbp->icb_fwoptions3 & ICB2400_OPT3_RSPSZ_MASK) == 0) {
2111                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RSPSZ_24;
2112         }
2113         if (isp->isp_confopts & ISP_CFG_1GB) {
2114                 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2115                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_1GB;
2116         } else if (isp->isp_confopts & ISP_CFG_2GB) {
2117                 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2118                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_2GB;
2119         } else if (isp->isp_confopts & ISP_CFG_4GB) {
2120                 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2121                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_4GB;
2122         } else if (isp->isp_confopts & ISP_CFG_8GB) {
2123                 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2124                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_8GB;
2125         } else if (isp->isp_confopts & ISP_CFG_16GB) {
2126                 icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2127                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_16GB;
2128         } else {
2129                 switch (icbp->icb_fwoptions3 & ICB2400_OPT3_RATE_MASK) {
2130                 case ICB2400_OPT3_RATE_4GB:
2131                 case ICB2400_OPT3_RATE_8GB:
2132                 case ICB2400_OPT3_RATE_16GB:
2133                 case ICB2400_OPT3_RATE_AUTO:
2134                         break;
2135                 case ICB2400_OPT3_RATE_2GB:
2136                         if (isp->isp_type <= ISP_HA_FC_2500)
2137                                 break;
2138                         /*FALLTHROUGH*/
2139                 case ICB2400_OPT3_RATE_1GB:
2140                         if (isp->isp_type <= ISP_HA_FC_2400)
2141                                 break;
2142                         /*FALLTHROUGH*/
2143                 default:
2144                         icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2145                         icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_AUTO;
2146                         break;
2147                 }
2148         }
2149         if (ownloopid == 0) {
2150                 icbp->icb_fwoptions3 |= ICB2400_OPT3_SOFTID;
2151         }
2152         icbp->icb_logintime = ICB_LOGIN_TOV;
2153
2154         if (fcp->isp_wwnn && fcp->isp_wwpn) {
2155                 icbp->icb_fwoptions1 |= ICB2400_OPT1_BOTH_WWNS;
2156                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
2157                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwnn);
2158                 isp_prt(isp, ISP_LOGDEBUG1, "Setting ICB Node 0x%08x%08x Port 0x%08x%08x", ((uint32_t) (fcp->isp_wwnn >> 32)), ((uint32_t) (fcp->isp_wwnn)),
2159                     ((uint32_t) (fcp->isp_wwpn >> 32)), ((uint32_t) (fcp->isp_wwpn)));
2160         } else if (fcp->isp_wwpn) {
2161                 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_BOTH_WWNS;
2162                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
2163                 isp_prt(isp, ISP_LOGDEBUG1, "Setting ICB Node to be same as Port 0x%08x%08x", ((uint32_t) (fcp->isp_wwpn >> 32)), ((uint32_t) (fcp->isp_wwpn)));
2164         } else {
2165                 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
2166                 return;
2167         }
2168         icbp->icb_retry_count = fcp->isp_retry_count;
2169
2170         icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
2171         if (icbp->icb_rqstqlen < 8) {
2172                 isp_prt(isp, ISP_LOGERR, "bad request queue length %d", icbp->icb_rqstqlen);
2173                 return;
2174         }
2175         icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
2176         if (icbp->icb_rsltqlen < 8) {
2177                 isp_prt(isp, ISP_LOGERR, "bad result queue length %d",
2178                     icbp->icb_rsltqlen);
2179                 return;
2180         }
2181         icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
2182         icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
2183         icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
2184         icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
2185
2186         icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
2187         icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
2188         icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
2189         icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
2190
2191 #ifdef  ISP_TARGET_MODE
2192         /* unconditionally set up the ATIO queue if we support target mode */
2193         icbp->icb_atioqlen = RESULT_QUEUE_LEN(isp);
2194         if (icbp->icb_atioqlen < 8) {
2195                 isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d", icbp->icb_atioqlen);
2196                 return;
2197         }
2198         icbp->icb_atioqaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_atioq_dma);
2199         icbp->icb_atioqaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_atioq_dma);
2200         icbp->icb_atioqaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_atioq_dma);
2201         icbp->icb_atioqaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_atioq_dma);
2202         isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init_2400: atioq %04x%04x%04x%04x", DMA_WD3(isp->isp_atioq_dma), DMA_WD2(isp->isp_atioq_dma),
2203             DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
2204 #endif
2205
2206         if (ISP_CAP_MSIX(isp) && isp->isp_nirq >= 2) {
2207                 icbp->icb_msixresp = 1;
2208                 if (IS_26XX(isp) && isp->isp_nirq >= 3)
2209                         icbp->icb_msixatio = 2;
2210         }
2211
2212         isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init_2400: fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x", icbp->icb_fwoptions1, icbp->icb_fwoptions2, icbp->icb_fwoptions3);
2213
2214         isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init_2400: rqst %04x%04x%04x%04x rsp %04x%04x%04x%04x", DMA_WD3(isp->isp_rquest_dma), DMA_WD2(isp->isp_rquest_dma),
2215             DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma), DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
2216             DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
2217
2218         if (FC_SCRATCH_ACQUIRE(isp, 0)) {
2219                 isp_prt(isp, ISP_LOGERR, sacq);
2220                 return;
2221         }
2222         ISP_MEMZERO(fcp->isp_scratch, ISP_FC_SCRLEN);
2223         isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
2224         if (isp->isp_dblev & ISP_LOGDEBUG1) {
2225                 isp_print_bytes(isp, "isp_fibre_init_2400",
2226                     sizeof (*icbp), fcp->isp_scratch);
2227         }
2228
2229         /*
2230          * Now fill in information about any additional channels
2231          */
2232         if (isp->isp_nchan > 1) {
2233                 isp_icb_2400_vpinfo_t vpinfo, *vdst;
2234                 vp_port_info_t pi, *pdst;
2235                 size_t amt = 0;
2236                 uint8_t *off;
2237
2238                 vpinfo.vp_global_options = ICB2400_VPGOPT_GEN_RIDA;
2239                 if (ISP_CAP_VP0(isp)) {
2240                         vpinfo.vp_global_options |= ICB2400_VPGOPT_VP0_DECOUPLE;
2241                         vpinfo.vp_count = isp->isp_nchan;
2242                         chan = 0;
2243                 } else {
2244                         vpinfo.vp_count = isp->isp_nchan - 1;
2245                         chan = 1;
2246                 }
2247                 off = fcp->isp_scratch;
2248                 off += ICB2400_VPINFO_OFF;
2249                 vdst = (isp_icb_2400_vpinfo_t *) off;
2250                 isp_put_icb_2400_vpinfo(isp, &vpinfo, vdst);
2251                 amt = ICB2400_VPINFO_OFF + sizeof (isp_icb_2400_vpinfo_t);
2252                 for (; chan < isp->isp_nchan; chan++) {
2253                         fcparam *fcp2;
2254
2255                         ISP_MEMZERO(&pi, sizeof (pi));
2256                         fcp2 = FCPARAM(isp, chan);
2257                         if (fcp2->role != ISP_ROLE_NONE) {
2258                                 pi.vp_port_options = ICB2400_VPOPT_ENABLED |
2259                                     ICB2400_VPOPT_ENA_SNSLOGIN;
2260                                 if (fcp2->role & ISP_ROLE_INITIATOR)
2261                                         pi.vp_port_options |= ICB2400_VPOPT_INI_ENABLE;
2262                                 if ((fcp2->role & ISP_ROLE_TARGET) == 0)
2263                                         pi.vp_port_options |= ICB2400_VPOPT_TGT_DISABLE;
2264                                 if (fcp2->isp_loopid < LOCAL_LOOP_LIM) {
2265                                         pi.vp_port_loopid = fcp2->isp_loopid;
2266                                         if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
2267                                                 pi.vp_port_options |= ICB2400_VPOPT_HARD_ADDRESS;
2268                                 }
2269
2270                         }
2271                         MAKE_NODE_NAME_FROM_WWN(pi.vp_port_portname, fcp2->isp_wwpn);
2272                         MAKE_NODE_NAME_FROM_WWN(pi.vp_port_nodename, fcp2->isp_wwnn);
2273                         off = fcp->isp_scratch;
2274                         if (ISP_CAP_VP0(isp))
2275                                 off += ICB2400_VPINFO_PORT_OFF(chan);
2276                         else
2277                                 off += ICB2400_VPINFO_PORT_OFF(chan - 1);
2278                         pdst = (vp_port_info_t *) off;
2279                         isp_put_vp_port_info(isp, &pi, pdst);
2280                         amt += ICB2400_VPOPT_WRITE_SIZE;
2281                 }
2282                 if (isp->isp_dblev & ISP_LOGDEBUG1) {
2283                         isp_print_bytes(isp, "isp_fibre_init_2400",
2284                             amt - ICB2400_VPINFO_OFF,
2285                             (char *)fcp->isp_scratch + ICB2400_VPINFO_OFF);
2286                 }
2287         }
2288
2289         /*
2290          * Init the firmware
2291          */
2292         MBSINIT(&mbs, 0, MBLOGALL, 30000000);
2293         if (isp->isp_nchan > 1) {
2294                 mbs.param[0] = MBOX_INIT_FIRMWARE_MULTI_ID;
2295         } else {
2296                 mbs.param[0] = MBOX_INIT_FIRMWARE;
2297         }
2298         mbs.param[1] = 0;
2299         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2300         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2301         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2302         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2303         isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %04x%04x%04x%04x", DMA_WD3(fcp->isp_scdma), DMA_WD2(fcp->isp_scdma), DMA_WD1(fcp->isp_scdma), DMA_WD0(fcp->isp_scdma));
2304         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
2305         isp_mboxcmd(isp, &mbs);
2306         FC_SCRATCH_RELEASE(isp, 0);
2307
2308         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2309                 return;
2310         }
2311         isp->isp_reqidx = 0;
2312         isp->isp_reqodx = 0;
2313         isp->isp_residx = 0;
2314         isp->isp_resodx = 0;
2315         isp->isp_atioodx = 0;
2316
2317         /*
2318          * Whatever happens, we're now committed to being here.
2319          */
2320         isp->isp_state = ISP_RUNSTATE;
2321 }
2322
2323 static int
2324 isp_fc_enable_vp(ispsoftc_t *isp, int chan)
2325 {
2326         fcparam *fcp = FCPARAM(isp, chan);
2327         vp_modify_t vp;
2328         void *reqp;
2329         uint8_t resp[QENTRY_LEN];
2330
2331         /* Build a VP MODIFY command in memory */
2332         ISP_MEMZERO(&vp, sizeof(vp));
2333         vp.vp_mod_hdr.rqs_entry_type = RQSTYPE_VP_MODIFY;
2334         vp.vp_mod_hdr.rqs_entry_count = 1;
2335         vp.vp_mod_cnt = 1;
2336         vp.vp_mod_idx0 = chan;
2337         vp.vp_mod_cmd = VP_MODIFY_ENA;
2338         vp.vp_mod_ports[0].options = ICB2400_VPOPT_ENABLED |
2339             ICB2400_VPOPT_ENA_SNSLOGIN;
2340         if (fcp->role & ISP_ROLE_INITIATOR)
2341                 vp.vp_mod_ports[0].options |= ICB2400_VPOPT_INI_ENABLE;
2342         if ((fcp->role & ISP_ROLE_TARGET) == 0)
2343                 vp.vp_mod_ports[0].options |= ICB2400_VPOPT_TGT_DISABLE;
2344         if (fcp->isp_loopid < LOCAL_LOOP_LIM) {
2345                 vp.vp_mod_ports[0].loopid = fcp->isp_loopid;
2346                 if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
2347                         vp.vp_mod_ports[0].options |= ICB2400_VPOPT_HARD_ADDRESS;
2348         }
2349         MAKE_NODE_NAME_FROM_WWN(vp.vp_mod_ports[0].wwpn, fcp->isp_wwpn);
2350         MAKE_NODE_NAME_FROM_WWN(vp.vp_mod_ports[0].wwnn, fcp->isp_wwnn);
2351
2352         /* Prepare space for response in memory */
2353         memset(resp, 0xff, sizeof(resp));
2354         vp.vp_mod_hdl = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2355         if (vp.vp_mod_hdl == 0) {
2356                 isp_prt(isp, ISP_LOGERR,
2357                     "%s: VP_MODIFY of Chan %d out of handles", __func__, chan);
2358                 return (EIO);
2359         }
2360
2361         /* Send request and wait for response. */
2362         reqp = isp_getrqentry(isp);
2363         if (reqp == NULL) {
2364                 isp_prt(isp, ISP_LOGERR,
2365                     "%s: VP_MODIFY of Chan %d out of rqent", __func__, chan);
2366                 isp_destroy_handle(isp, vp.vp_mod_hdl);
2367                 return (EIO);
2368         }
2369         isp_put_vp_modify(isp, &vp, (vp_modify_t *)reqp);
2370         if (isp->isp_dblev & ISP_LOGDEBUG1)
2371                 isp_print_bytes(isp, "IOCB VP_MODIFY", QENTRY_LEN, reqp);
2372         ISP_SYNC_REQUEST(isp);
2373         if (msleep(resp, &isp->isp_lock, 0, "VP_MODIFY", 5*hz) == EWOULDBLOCK) {
2374                 isp_prt(isp, ISP_LOGERR,
2375                     "%s: VP_MODIFY of Chan %d timed out", __func__, chan);
2376                 isp_destroy_handle(isp, vp.vp_mod_hdl);
2377                 return (EIO);
2378         }
2379         if (isp->isp_dblev & ISP_LOGDEBUG1)
2380                 isp_print_bytes(isp, "IOCB VP_MODIFY response", QENTRY_LEN, resp);
2381         isp_get_vp_modify(isp, (vp_modify_t *)resp, &vp);
2382
2383         if (vp.vp_mod_hdr.rqs_flags != 0 || vp.vp_mod_status != VP_STS_OK) {
2384                 isp_prt(isp, ISP_LOGERR,
2385                     "%s: VP_MODIFY of Chan %d failed with flags %x status %d",
2386                     __func__, chan, vp.vp_mod_hdr.rqs_flags, vp.vp_mod_status);
2387                 return (EIO);
2388         }
2389         return (0);
2390 }
2391
2392 static int
2393 isp_fc_disable_vp(ispsoftc_t *isp, int chan)
2394 {
2395         vp_ctrl_info_t vp;
2396         void *reqp;
2397         uint8_t resp[QENTRY_LEN];
2398
2399         /* Build a VP CTRL command in memory */
2400         ISP_MEMZERO(&vp, sizeof(vp));
2401         vp.vp_ctrl_hdr.rqs_entry_type = RQSTYPE_VP_CTRL;
2402         vp.vp_ctrl_hdr.rqs_entry_count = 1;
2403         if (ISP_CAP_VP0(isp)) {
2404                 vp.vp_ctrl_status = 1;
2405         } else {
2406                 vp.vp_ctrl_status = 0;
2407                 chan--; /* VP0 can not be controlled in this case. */
2408         }
2409         vp.vp_ctrl_command = VP_CTRL_CMD_DISABLE_VP_LOGO_ALL;
2410         vp.vp_ctrl_vp_count = 1;
2411         vp.vp_ctrl_idmap[chan / 16] |= (1 << chan % 16);
2412
2413         /* Prepare space for response in memory */
2414         memset(resp, 0xff, sizeof(resp));
2415         vp.vp_ctrl_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2416         if (vp.vp_ctrl_handle == 0) {
2417                 isp_prt(isp, ISP_LOGERR,
2418                     "%s: VP_CTRL of Chan %d out of handles", __func__, chan);
2419                 return (EIO);
2420         }
2421
2422         /* Send request and wait for response. */
2423         reqp = isp_getrqentry(isp);
2424         if (reqp == NULL) {
2425                 isp_prt(isp, ISP_LOGERR,
2426                     "%s: VP_CTRL of Chan %d out of rqent", __func__, chan);
2427                 isp_destroy_handle(isp, vp.vp_ctrl_handle);
2428                 return (EIO);
2429         }
2430         isp_put_vp_ctrl_info(isp, &vp, (vp_ctrl_info_t *)reqp);
2431         if (isp->isp_dblev & ISP_LOGDEBUG1)
2432                 isp_print_bytes(isp, "IOCB VP_CTRL", QENTRY_LEN, reqp);
2433         ISP_SYNC_REQUEST(isp);
2434         if (msleep(resp, &isp->isp_lock, 0, "VP_CTRL", 5*hz) == EWOULDBLOCK) {
2435                 isp_prt(isp, ISP_LOGERR,
2436                     "%s: VP_CTRL of Chan %d timed out", __func__, chan);
2437                 isp_destroy_handle(isp, vp.vp_ctrl_handle);
2438                 return (EIO);
2439         }
2440         if (isp->isp_dblev & ISP_LOGDEBUG1)
2441                 isp_print_bytes(isp, "IOCB VP_CTRL response", QENTRY_LEN, resp);
2442         isp_get_vp_ctrl_info(isp, (vp_ctrl_info_t *)resp, &vp);
2443
2444         if (vp.vp_ctrl_hdr.rqs_flags != 0 || vp.vp_ctrl_status != 0) {
2445                 isp_prt(isp, ISP_LOGERR,
2446                     "%s: VP_CTRL of Chan %d failed with flags %x status %d %d",
2447                     __func__, chan, vp.vp_ctrl_hdr.rqs_flags,
2448                     vp.vp_ctrl_status, vp.vp_ctrl_index_fail);
2449                 return (EIO);
2450         }
2451         return (0);
2452 }
2453
2454 static int
2455 isp_fc_change_role(ispsoftc_t *isp, int chan, int new_role)
2456 {
2457         fcparam *fcp = FCPARAM(isp, chan);
2458         int i, was, res = 0;
2459
2460         if (chan >= isp->isp_nchan) {
2461                 isp_prt(isp, ISP_LOGWARN, "%s: bad channel %d", __func__, chan);
2462                 return (ENXIO);
2463         }
2464         if (fcp->role == new_role)
2465                 return (0);
2466         for (was = 0, i = 0; i < isp->isp_nchan; i++) {
2467                 if (FCPARAM(isp, i)->role != ISP_ROLE_NONE)
2468                         was++;
2469         }
2470         if (was == 0 || (was == 1 && fcp->role != ISP_ROLE_NONE)) {
2471                 fcp->role = new_role;
2472                 return (isp_reinit(isp, 0));
2473         }
2474         if (fcp->role != ISP_ROLE_NONE) {
2475                 res = isp_fc_disable_vp(isp, chan);
2476                 isp_clear_portdb(isp, chan);
2477         }
2478         fcp->role = new_role;
2479         if (fcp->role != ISP_ROLE_NONE)
2480                 res = isp_fc_enable_vp(isp, chan);
2481         return (res);
2482 }
2483
2484 static void
2485 isp_clear_portdb(ispsoftc_t *isp, int chan)
2486 {
2487         fcparam *fcp = FCPARAM(isp, chan);
2488         fcportdb_t *lp;
2489         int i;
2490
2491         for (i = 0; i < MAX_FC_TARG; i++) {
2492                 lp = &fcp->portdb[i];
2493                 switch (lp->state) {
2494                 case FC_PORTDB_STATE_DEAD:
2495                 case FC_PORTDB_STATE_CHANGED:
2496                 case FC_PORTDB_STATE_VALID:
2497                         lp->state = FC_PORTDB_STATE_NIL;
2498                         isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
2499                         break;
2500                 case FC_PORTDB_STATE_NIL:
2501                 case FC_PORTDB_STATE_NEW:
2502                         lp->state = FC_PORTDB_STATE_NIL;
2503                         break;
2504                 case FC_PORTDB_STATE_ZOMBIE:
2505                         break;
2506                 default:
2507                         panic("Don't know how to clear state %d\n", lp->state);
2508                 }
2509         }
2510 }
2511
2512 static void
2513 isp_mark_portdb(ispsoftc_t *isp, int chan)
2514 {
2515         fcparam *fcp = FCPARAM(isp, chan);
2516         fcportdb_t *lp;
2517         int i;
2518
2519         for (i = 0; i < MAX_FC_TARG; i++) {
2520                 lp = &fcp->portdb[i];
2521                 if (lp->state == FC_PORTDB_STATE_NIL)
2522                         continue;
2523                 if (lp->portid >= DOMAIN_CONTROLLER_BASE &&
2524                     lp->portid <= DOMAIN_CONTROLLER_END)
2525                         continue;
2526                 fcp->portdb[i].probational = 1;
2527         }
2528 }
2529
2530 /*
2531  * Perform an IOCB PLOGI or LOGO via EXECUTE IOCB A64 for 24XX cards
2532  * or via FABRIC LOGIN/FABRIC LOGOUT for other cards.
2533  */
2534 static int
2535 isp_plogx(ispsoftc_t *isp, int chan, uint16_t handle, uint32_t portid, int flags)
2536 {
2537         isp_plogx_t pl;
2538         void *reqp;
2539         uint8_t resp[QENTRY_LEN];
2540         uint32_t sst, parm1;
2541         int rval, lev;
2542         const char *msg;
2543         char buf[64];
2544
2545         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d PLOGX %s PortID 0x%06x nphdl 0x%x",
2546             chan, (flags & PLOGX_FLG_CMD_MASK) == PLOGX_FLG_CMD_PLOGI ?
2547             "Login":"Logout", portid, handle);
2548         if (!IS_24XX(isp)) {
2549                 int action = flags & PLOGX_FLG_CMD_MASK;
2550                 if (action == PLOGX_FLG_CMD_PLOGI) {
2551                         return (isp_port_login(isp, handle, portid));
2552                 } else if (action == PLOGX_FLG_CMD_LOGO) {
2553                         return (isp_port_logout(isp, handle, portid));
2554                 } else {
2555                         return (MBOX_INVALID_COMMAND);
2556                 }
2557         }
2558
2559         ISP_MEMZERO(&pl, sizeof(pl));
2560         pl.plogx_header.rqs_entry_count = 1;
2561         pl.plogx_header.rqs_entry_type = RQSTYPE_LOGIN;
2562         pl.plogx_nphdl = handle;
2563         pl.plogx_vphdl = chan;
2564         pl.plogx_portlo = portid;
2565         pl.plogx_rspsz_porthi = (portid >> 16) & 0xff;
2566         pl.plogx_flags = flags;
2567
2568         /* Prepare space for response in memory */
2569         memset(resp, 0xff, sizeof(resp));
2570         pl.plogx_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2571         if (pl.plogx_handle == 0) {
2572                 isp_prt(isp, ISP_LOGERR,
2573                     "%s: PLOGX of Chan %d out of handles", __func__, chan);
2574                 return (-1);
2575         }
2576
2577         /* Send request and wait for response. */
2578         reqp = isp_getrqentry(isp);
2579         if (reqp == NULL) {
2580                 isp_prt(isp, ISP_LOGERR,
2581                     "%s: PLOGX of Chan %d out of rqent", __func__, chan);
2582                 isp_destroy_handle(isp, pl.plogx_handle);
2583                 return (-1);
2584         }
2585         isp_put_plogx(isp, &pl, (isp_plogx_t *)reqp);
2586         if (isp->isp_dblev & ISP_LOGDEBUG1)
2587                 isp_print_bytes(isp, "IOCB LOGX", QENTRY_LEN, reqp);
2588         FCPARAM(isp, chan)->isp_login_hdl = handle;
2589         ISP_SYNC_REQUEST(isp);
2590         if (msleep(resp, &isp->isp_lock, 0, "PLOGX", 3 * ICB_LOGIN_TOV * hz)
2591             == EWOULDBLOCK) {
2592                 isp_prt(isp, ISP_LOGERR,
2593                     "%s: PLOGX of Chan %d timed out", __func__, chan);
2594                 isp_destroy_handle(isp, pl.plogx_handle);
2595                 return (-1);
2596         }
2597         FCPARAM(isp, chan)->isp_login_hdl = NIL_HANDLE;
2598         if (isp->isp_dblev & ISP_LOGDEBUG1)
2599                 isp_print_bytes(isp, "IOCB LOGX response", QENTRY_LEN, resp);
2600         isp_get_plogx(isp, (isp_plogx_t *)resp, &pl);
2601
2602         if (pl.plogx_status == PLOGX_STATUS_OK) {
2603                 return (0);
2604         } else if (pl.plogx_status != PLOGX_STATUS_IOCBERR) {
2605                 isp_prt(isp, ISP_LOGWARN,
2606                     "status 0x%x on port login IOCB channel %d",
2607                     pl.plogx_status, chan);
2608                 return (-1);
2609         }
2610
2611         sst = pl.plogx_ioparm[0].lo16 | (pl.plogx_ioparm[0].hi16 << 16);
2612         parm1 = pl.plogx_ioparm[1].lo16 | (pl.plogx_ioparm[1].hi16 << 16);
2613
2614         rval = -1;
2615         lev = ISP_LOGERR;
2616         msg = NULL;
2617
2618         switch (sst) {
2619         case PLOGX_IOCBERR_NOLINK:
2620                 msg = "no link";
2621                 break;
2622         case PLOGX_IOCBERR_NOIOCB:
2623                 msg = "no IOCB buffer";
2624                 break;
2625         case PLOGX_IOCBERR_NOXGHG:
2626                 msg = "no Exchange Control Block";
2627                 break;
2628         case PLOGX_IOCBERR_FAILED:
2629                 ISP_SNPRINTF(buf, sizeof (buf), "reason 0x%x (last LOGIN state 0x%x)", parm1 & 0xff, (parm1 >> 8) & 0xff);
2630                 msg = buf;
2631                 break;
2632         case PLOGX_IOCBERR_NOFABRIC:
2633                 msg = "no fabric";
2634                 break;
2635         case PLOGX_IOCBERR_NOTREADY:
2636                 msg = "firmware not ready";
2637                 break;
2638         case PLOGX_IOCBERR_NOLOGIN:
2639                 ISP_SNPRINTF(buf, sizeof (buf), "not logged in (last state 0x%x)", parm1);
2640                 msg = buf;
2641                 rval = MBOX_NOT_LOGGED_IN;
2642                 break;
2643         case PLOGX_IOCBERR_REJECT:
2644                 ISP_SNPRINTF(buf, sizeof (buf), "LS_RJT = 0x%x", parm1);
2645                 msg = buf;
2646                 break;
2647         case PLOGX_IOCBERR_NOPCB:
2648                 msg = "no PCB allocated";
2649                 break;
2650         case PLOGX_IOCBERR_EINVAL:
2651                 ISP_SNPRINTF(buf, sizeof (buf), "invalid parameter at offset 0x%x", parm1);
2652                 msg = buf;
2653                 break;
2654         case PLOGX_IOCBERR_PORTUSED:
2655                 lev = ISP_LOG_SANCFG|ISP_LOG_WARN1;
2656                 ISP_SNPRINTF(buf, sizeof (buf), "already logged in with N-Port handle 0x%x", parm1);
2657                 msg = buf;
2658                 rval = MBOX_PORT_ID_USED | (parm1 << 16);
2659                 break;
2660         case PLOGX_IOCBERR_HNDLUSED:
2661                 lev = ISP_LOG_SANCFG|ISP_LOG_WARN1;
2662                 ISP_SNPRINTF(buf, sizeof (buf), "handle already used for PortID 0x%06x", parm1);
2663                 msg = buf;
2664                 rval = MBOX_LOOP_ID_USED;
2665                 break;
2666         case PLOGX_IOCBERR_NOHANDLE:
2667                 msg = "no handle allocated";
2668                 break;
2669         case PLOGX_IOCBERR_NOFLOGI:
2670                 msg = "no FLOGI_ACC";
2671                 break;
2672         default:
2673                 ISP_SNPRINTF(buf, sizeof (buf), "status %x from %x", pl.plogx_status, flags);
2674                 msg = buf;
2675                 break;
2676         }
2677         if (msg) {
2678                 isp_prt(isp, lev, "Chan %d PLOGX PortID 0x%06x to N-Port handle 0x%x: %s",
2679                     chan, portid, handle, msg);
2680         }
2681         return (rval);
2682 }
2683
2684 static int
2685 isp_port_login(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2686 {
2687         mbreg_t mbs;
2688
2689         MBSINIT(&mbs, MBOX_FABRIC_LOGIN, MBLOGNONE, 500000);
2690         if (ISP_CAP_2KLOGIN(isp)) {
2691                 mbs.param[1] = handle;
2692                 mbs.ibits = (1 << 10);
2693         } else {
2694                 mbs.param[1] = handle << 8;
2695         }
2696         mbs.param[2] = portid >> 16;
2697         mbs.param[3] = portid;
2698         mbs.logval = MBLOGNONE;
2699         mbs.timeout = 500000;
2700         isp_mboxcmd(isp, &mbs);
2701
2702         switch (mbs.param[0]) {
2703         case MBOX_PORT_ID_USED:
2704                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: portid 0x%06x already logged in as 0x%x", portid, mbs.param[1]);
2705                 return (MBOX_PORT_ID_USED | (mbs.param[1] << 16));
2706
2707         case MBOX_LOOP_ID_USED:
2708                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: handle 0x%x in use for port id 0x%02xXXXX", handle, mbs.param[1] & 0xff);
2709                 return (MBOX_LOOP_ID_USED);
2710
2711         case MBOX_COMMAND_COMPLETE:
2712                 return (0);
2713
2714         case MBOX_COMMAND_ERROR:
2715                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: error 0x%x in PLOGI to port 0x%06x", mbs.param[1], portid);
2716                 return (MBOX_COMMAND_ERROR);
2717
2718         case MBOX_ALL_IDS_USED:
2719                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: all IDs used for fabric login");
2720                 return (MBOX_ALL_IDS_USED);
2721
2722         default:
2723                 isp_prt(isp, ISP_LOG_SANCFG, "isp_port_login: error 0x%x on port login of 0x%06x@0x%0x", mbs.param[0], portid, handle);
2724                 return (mbs.param[0]);
2725         }
2726 }
2727
2728 /*
2729  * Pre-24XX fabric port logout
2730  *
2731  * Note that portid is not used
2732  */
2733 static int
2734 isp_port_logout(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2735 {
2736         mbreg_t mbs;
2737
2738         MBSINIT(&mbs, MBOX_FABRIC_LOGOUT, MBLOGNONE, 500000);
2739         if (ISP_CAP_2KLOGIN(isp)) {
2740                 mbs.param[1] = handle;
2741                 mbs.ibits = (1 << 10);
2742         } else {
2743                 mbs.param[1] = handle << 8;
2744         }
2745         isp_mboxcmd(isp, &mbs);
2746         return (mbs.param[0] == MBOX_COMMAND_COMPLETE? 0 : mbs.param[0]);
2747 }
2748
2749 static int
2750 isp_getpdb(ispsoftc_t *isp, int chan, uint16_t id, isp_pdb_t *pdb)
2751 {
2752         mbreg_t mbs;
2753         union {
2754                 isp_pdb_21xx_t fred;
2755                 isp_pdb_24xx_t bill;
2756         } un;
2757
2758         MBSINIT(&mbs, MBOX_GET_PORT_DB,
2759             MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_PARAM_ERROR), 250000);
2760         if (IS_24XX(isp)) {
2761                 mbs.ibits = (1 << 9)|(1 << 10);
2762                 mbs.param[1] = id;
2763                 mbs.param[9] = chan;
2764         } else if (ISP_CAP_2KLOGIN(isp)) {
2765                 mbs.param[1] = id;
2766         } else {
2767                 mbs.param[1] = id << 8;
2768         }
2769         mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
2770         mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
2771         mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
2772         mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
2773         MEMORYBARRIER(isp, SYNC_IFORDEV, 0, sizeof(un), chan);
2774
2775         isp_mboxcmd(isp, &mbs);
2776         if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
2777                 return (mbs.param[0] | (mbs.param[1] << 16));
2778
2779         MEMORYBARRIER(isp, SYNC_IFORCPU, 0, sizeof(un), chan);
2780         if (IS_24XX(isp)) {
2781                 isp_get_pdb_24xx(isp, isp->isp_iocb, &un.bill);
2782                 pdb->handle = un.bill.pdb_handle;
2783                 pdb->prli_word3 = un.bill.pdb_prli_svc3;
2784                 pdb->portid = BITS2WORD_24XX(un.bill.pdb_portid_bits);
2785                 ISP_MEMCPY(pdb->portname, un.bill.pdb_portname, 8);
2786                 ISP_MEMCPY(pdb->nodename, un.bill.pdb_nodename, 8);
2787                 isp_prt(isp, ISP_LOGDEBUG0,
2788                     "Chan %d handle 0x%x Port 0x%06x flags 0x%x curstate %x laststate %x",
2789                     chan, id, pdb->portid, un.bill.pdb_flags,
2790                     un.bill.pdb_curstate, un.bill.pdb_laststate);
2791
2792                 if (un.bill.pdb_curstate < PDB2400_STATE_PLOGI_DONE || un.bill.pdb_curstate > PDB2400_STATE_LOGGED_IN) {
2793                         mbs.param[0] = MBOX_NOT_LOGGED_IN;
2794                         return (mbs.param[0]);
2795                 }
2796         } else {
2797                 isp_get_pdb_21xx(isp, isp->isp_iocb, &un.fred);
2798                 pdb->handle = un.fred.pdb_loopid;
2799                 pdb->prli_word3 = un.fred.pdb_prli_svc3;
2800                 pdb->portid = BITS2WORD(un.fred.pdb_portid_bits);
2801                 ISP_MEMCPY(pdb->portname, un.fred.pdb_portname, 8);
2802                 ISP_MEMCPY(pdb->nodename, un.fred.pdb_nodename, 8);
2803                 isp_prt(isp, ISP_LOGDEBUG1,
2804                     "Chan %d handle 0x%x Port 0x%06x", chan, id, pdb->portid);
2805         }
2806         return (0);
2807 }
2808
2809 static int
2810 isp_gethandles(ispsoftc_t *isp, int chan, uint16_t *handles, int *num, int loop)
2811 {
2812         fcparam *fcp = FCPARAM(isp, chan);
2813         mbreg_t mbs;
2814         isp_pnhle_21xx_t el1, *elp1;
2815         isp_pnhle_23xx_t el3, *elp3;
2816         isp_pnhle_24xx_t el4, *elp4;
2817         int i, j;
2818         uint32_t p;
2819         uint16_t h;
2820
2821         MBSINIT(&mbs, MBOX_GET_ID_LIST, MBLOGALL, 250000);
2822         if (IS_24XX(isp)) {
2823                 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2824                 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2825                 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2826                 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2827                 mbs.param[8] = ISP_FC_SCRLEN;
2828                 mbs.param[9] = chan;
2829         } else {
2830                 mbs.ibits = (1 << 1)|(1 << 2)|(1 << 3)|(1 << 6);
2831                 mbs.param[1] = DMA_WD1(fcp->isp_scdma);
2832                 mbs.param[2] = DMA_WD0(fcp->isp_scdma);
2833                 mbs.param[3] = DMA_WD3(fcp->isp_scdma);
2834                 mbs.param[6] = DMA_WD2(fcp->isp_scdma);
2835         }
2836         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2837                 isp_prt(isp, ISP_LOGERR, sacq);
2838                 return (-1);
2839         }
2840         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, ISP_FC_SCRLEN, chan);
2841         isp_mboxcmd(isp, &mbs);
2842         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2843                 FC_SCRATCH_RELEASE(isp, chan);
2844                 return (mbs.param[0] | (mbs.param[1] << 16));
2845         }
2846         MEMORYBARRIER(isp, SYNC_SFORCPU, 0, ISP_FC_SCRLEN, chan);
2847         elp1 = fcp->isp_scratch;
2848         elp3 = fcp->isp_scratch;
2849         elp4 = fcp->isp_scratch;
2850         for (i = 0, j = 0; i < mbs.param[1] && j < *num; i++) {
2851                 if (IS_24XX(isp)) {
2852                         isp_get_pnhle_24xx(isp, &elp4[i], &el4);
2853                         p = el4.pnhle_port_id_lo |
2854                             (el4.pnhle_port_id_hi << 16);
2855                         h = el4.pnhle_handle;
2856                 } else if (IS_23XX(isp)) {
2857                         isp_get_pnhle_23xx(isp, &elp3[i], &el3);
2858                         p = el3.pnhle_port_id_lo |
2859                             (el3.pnhle_port_id_hi << 16);
2860                         h = el3.pnhle_handle;
2861                 } else { /* 21xx */
2862                         isp_get_pnhle_21xx(isp, &elp1[i], &el1);
2863                         p = el1.pnhle_port_id_lo |
2864                             ((el1.pnhle_port_id_hi_handle & 0xff) << 16);
2865                         h = el1.pnhle_port_id_hi_handle >> 8;
2866                 }
2867                 if (loop && (p >> 8) != (fcp->isp_portid >> 8))
2868                         continue;
2869                 handles[j++] = h;
2870         }
2871         *num = j;
2872         FC_SCRATCH_RELEASE(isp, chan);
2873         return (0);
2874 }
2875
2876 static void
2877 isp_dump_chip_portdb(ispsoftc_t *isp, int chan)
2878 {
2879         isp_pdb_t pdb;
2880         uint16_t lim, nphdl;
2881
2882         isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d chip port dump", chan);
2883         if (ISP_CAP_2KLOGIN(isp)) {
2884                 lim = NPH_MAX_2K;
2885         } else {
2886                 lim = NPH_MAX;
2887         }
2888         for (nphdl = 0; nphdl != lim; nphdl++) {
2889                 if (isp_getpdb(isp, chan, nphdl, &pdb)) {
2890                         continue;
2891                 }
2892                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d Handle 0x%04x "
2893                     "PortID 0x%06x WWPN 0x%02x%02x%02x%02x%02x%02x%02x%02x",
2894                     chan, nphdl, pdb.portid, pdb.portname[0], pdb.portname[1],
2895                     pdb.portname[2], pdb.portname[3], pdb.portname[4],
2896                     pdb.portname[5], pdb.portname[6], pdb.portname[7]);
2897         }
2898 }
2899
2900 static uint64_t
2901 isp_get_wwn(ispsoftc_t *isp, int chan, int nphdl, int nodename)
2902 {
2903         uint64_t wwn = INI_NONE;
2904         mbreg_t mbs;
2905
2906         MBSINIT(&mbs, MBOX_GET_PORT_NAME,
2907             MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_PARAM_ERROR), 500000);
2908         if (ISP_CAP_2KLOGIN(isp)) {
2909                 mbs.param[1] = nphdl;
2910                 if (nodename) {
2911                         mbs.param[10] = 1;
2912                 }
2913                 mbs.param[9] = chan;
2914         } else {
2915                 mbs.ibitm = 3;
2916                 mbs.param[1] = nphdl << 8;
2917                 if (nodename) {
2918                         mbs.param[1] |= 1;
2919                 }
2920         }
2921         isp_mboxcmd(isp, &mbs);
2922         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2923                 return (wwn);
2924         }
2925         if (IS_24XX(isp)) {
2926                 wwn =
2927                     (((uint64_t)(mbs.param[2] >> 8))    << 56) |
2928                     (((uint64_t)(mbs.param[2] & 0xff))  << 48) |
2929                     (((uint64_t)(mbs.param[3] >> 8))    << 40) |
2930                     (((uint64_t)(mbs.param[3] & 0xff))  << 32) |
2931                     (((uint64_t)(mbs.param[6] >> 8))    << 24) |
2932                     (((uint64_t)(mbs.param[6] & 0xff))  << 16) |
2933                     (((uint64_t)(mbs.param[7] >> 8))    <<  8) |
2934                     (((uint64_t)(mbs.param[7] & 0xff)));
2935         } else {
2936                 wwn =
2937                     (((uint64_t)(mbs.param[2] & 0xff))  << 56) |
2938                     (((uint64_t)(mbs.param[2] >> 8))    << 48) |
2939                     (((uint64_t)(mbs.param[3] & 0xff))  << 40) |
2940                     (((uint64_t)(mbs.param[3] >> 8))    << 32) |
2941                     (((uint64_t)(mbs.param[6] & 0xff))  << 24) |
2942                     (((uint64_t)(mbs.param[6] >> 8))    << 16) |
2943                     (((uint64_t)(mbs.param[7] & 0xff))  <<  8) |
2944                     (((uint64_t)(mbs.param[7] >> 8)));
2945         }
2946         return (wwn);
2947 }
2948
2949 /*
2950  * Make sure we have good FC link.
2951  */
2952
2953 static int
2954 isp_fclink_test(ispsoftc_t *isp, int chan, int usdelay)
2955 {
2956         mbreg_t mbs;
2957         int i, r;
2958         uint16_t nphdl;
2959         fcparam *fcp;
2960         isp_pdb_t pdb;
2961         NANOTIME_T hra, hrb;
2962
2963         fcp = FCPARAM(isp, chan);
2964
2965         if (fcp->isp_loopstate < LOOP_HAVE_LINK)
2966                 return (-1);
2967         if (fcp->isp_loopstate >= LOOP_LTEST_DONE)
2968                 return (0);
2969
2970         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test", chan);
2971
2972         /*
2973          * Wait up to N microseconds for F/W to go to a ready state.
2974          */
2975         GET_NANOTIME(&hra);
2976         while (1) {
2977                 isp_change_fw_state(isp, chan, isp_fw_state(isp, chan));
2978                 if (fcp->isp_fwstate == FW_READY) {
2979                         break;
2980                 }
2981                 if (fcp->isp_loopstate < LOOP_HAVE_LINK)
2982                         goto abort;
2983                 GET_NANOTIME(&hrb);
2984                 if ((NANOTIME_SUB(&hrb, &hra) / 1000 + 1000 >= usdelay))
2985                         break;
2986                 ISP_SLEEP(isp, 1000);
2987         }
2988         if (fcp->isp_fwstate != FW_READY) {
2989                 isp_prt(isp, ISP_LOG_SANCFG,
2990                     "Chan %d Firmware is not ready (%s)",
2991                     chan, isp_fc_fw_statename(fcp->isp_fwstate));
2992                 return (-1);
2993         }
2994
2995         /*
2996          * Get our Loop ID and Port ID.
2997          */
2998         MBSINIT(&mbs, MBOX_GET_LOOP_ID, MBLOGALL, 0);
2999         mbs.param[9] = chan;
3000         isp_mboxcmd(isp, &mbs);
3001         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3002                 return (-1);
3003         }
3004
3005         if (IS_2100(isp)) {
3006                 /*
3007                  * Don't bother with fabric if we are using really old
3008                  * 2100 firmware. It's just not worth it.
3009                  */
3010                 if (ISP_FW_NEWER_THAN(isp, 1, 15, 37))
3011                         fcp->isp_topo = TOPO_FL_PORT;
3012                 else
3013                         fcp->isp_topo = TOPO_NL_PORT;
3014         } else {
3015                 int topo = (int) mbs.param[6];
3016                 if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB) {
3017                         topo = TOPO_PTP_STUB;
3018                 }
3019                 fcp->isp_topo = topo;
3020         }
3021         fcp->isp_portid = mbs.param[2] | (mbs.param[3] << 16);
3022
3023         if (!TOPO_IS_FABRIC(fcp->isp_topo)) {
3024                 fcp->isp_loopid = mbs.param[1] & 0xff;
3025         } else if (fcp->isp_topo != TOPO_F_PORT) {
3026                 uint8_t alpa = fcp->isp_portid;
3027
3028                 for (i = 0; alpa_map[i]; i++) {
3029                         if (alpa_map[i] == alpa)
3030                                 break;
3031                 }
3032                 if (alpa_map[i])
3033                         fcp->isp_loopid = i;
3034         }
3035
3036 #if 0
3037         fcp->isp_loopstate = LOOP_HAVE_ADDR;
3038 #endif
3039         fcp->isp_loopstate = LOOP_TESTING_LINK;
3040
3041         if (fcp->isp_topo == TOPO_F_PORT || fcp->isp_topo == TOPO_FL_PORT) {
3042                 nphdl = IS_24XX(isp) ? NPH_FL_ID : FL_ID;
3043                 r = isp_getpdb(isp, chan, nphdl, &pdb);
3044                 if (r != 0 || pdb.portid == 0) {
3045                         if (IS_2100(isp)) {
3046                                 fcp->isp_topo = TOPO_NL_PORT;
3047                         } else {
3048                                 isp_prt(isp, ISP_LOGWARN,
3049                                     "fabric topology, but cannot get info about fabric controller (0x%x)", r);
3050                                 fcp->isp_topo = TOPO_PTP_STUB;
3051                         }
3052                         goto not_on_fabric;
3053                 }
3054
3055                 if (IS_24XX(isp)) {
3056                         fcp->isp_fabric_params = mbs.param[7];
3057                         fcp->isp_sns_hdl = NPH_SNS_ID;
3058                         r = isp_register_fc4_type(isp, chan);
3059                         if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3060                                 goto abort;
3061                         if (r != 0)
3062                                 goto not_on_fabric;
3063                         r = isp_register_fc4_features_24xx(isp, chan);
3064                         if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3065                                 goto abort;
3066                         if (r != 0)
3067                                 goto not_on_fabric;
3068                         r = isp_register_port_name_24xx(isp, chan);
3069                         if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3070                                 goto abort;
3071                         if (r != 0)
3072                                 goto not_on_fabric;
3073                         isp_register_node_name_24xx(isp, chan);
3074                         if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3075                                 goto abort;
3076                 } else {
3077                         fcp->isp_sns_hdl = SNS_ID;
3078                         r = isp_register_fc4_type(isp, chan);
3079                         if (r != 0)
3080                                 goto not_on_fabric;
3081                         if (fcp->role == ISP_ROLE_TARGET)
3082                                 isp_send_change_request(isp, chan);
3083                 }
3084         }
3085
3086 not_on_fabric:
3087         /* Get link speed. */
3088         fcp->isp_gbspeed = 1;
3089         if (IS_23XX(isp) || IS_24XX(isp)) {
3090                 MBSINIT(&mbs, MBOX_GET_SET_DATA_RATE, MBLOGALL, 3000000);
3091                 mbs.param[1] = MBGSD_GET_RATE;
3092                 /* mbs.param[2] undefined if we're just getting rate */
3093                 isp_mboxcmd(isp, &mbs);
3094                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3095                         if (mbs.param[1] == MBGSD_10GB)
3096                                 fcp->isp_gbspeed = 10;
3097                         else if (mbs.param[1] == MBGSD_16GB)
3098                                 fcp->isp_gbspeed = 16;
3099                         else if (mbs.param[1] == MBGSD_8GB)
3100                                 fcp->isp_gbspeed = 8;
3101                         else if (mbs.param[1] == MBGSD_4GB)
3102                                 fcp->isp_gbspeed = 4;
3103                         else if (mbs.param[1] == MBGSD_2GB)
3104                                 fcp->isp_gbspeed = 2;
3105                         else if (mbs.param[1] == MBGSD_1GB)
3106                                 fcp->isp_gbspeed = 1;
3107                 }
3108         }
3109
3110         if (fcp->isp_loopstate < LOOP_TESTING_LINK) {
3111 abort:
3112                 isp_prt(isp, ISP_LOG_SANCFG,
3113                     "Chan %d FC link test aborted", chan);
3114                 return (1);
3115         }
3116         fcp->isp_loopstate = LOOP_LTEST_DONE;
3117         isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
3118             "Chan %d WWPN %016jx WWNN %016jx",
3119             chan, (uintmax_t)fcp->isp_wwpn, (uintmax_t)fcp->isp_wwnn);
3120         isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
3121             "Chan %d %dGb %s PortID 0x%06x LoopID 0x%02x",
3122             chan, fcp->isp_gbspeed, isp_fc_toponame(fcp), fcp->isp_portid,
3123             fcp->isp_loopid);
3124         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test done", chan);
3125         return (0);
3126 }
3127
3128 /*
3129  * Complete the synchronization of our Port Database.
3130  *
3131  * At this point, we've scanned the local loop (if any) and the fabric
3132  * and performed fabric logins on all new devices.
3133  *
3134  * Our task here is to go through our port database removing any entities
3135  * that are still marked probational (issuing PLOGO for ones which we had
3136  * PLOGI'd into) or are dead, and notifying upper layers about new/changed
3137  * devices.
3138  */
3139 static int
3140 isp_pdb_sync(ispsoftc_t *isp, int chan)
3141 {
3142         fcparam *fcp = FCPARAM(isp, chan);
3143         fcportdb_t *lp;
3144         uint16_t dbidx;
3145
3146         if (fcp->isp_loopstate < LOOP_FSCAN_DONE)
3147                 return (-1);
3148         if (fcp->isp_loopstate >= LOOP_READY)
3149                 return (0);
3150
3151         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync", chan);
3152
3153         fcp->isp_loopstate = LOOP_SYNCING_PDB;
3154
3155         for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3156                 lp = &fcp->portdb[dbidx];
3157
3158                 if (lp->state == FC_PORTDB_STATE_NIL)
3159                         continue;
3160                 if (lp->probational && lp->state != FC_PORTDB_STATE_ZOMBIE)
3161                         lp->state = FC_PORTDB_STATE_DEAD;
3162                 switch (lp->state) {
3163                 case FC_PORTDB_STATE_DEAD:
3164                         lp->state = FC_PORTDB_STATE_NIL;
3165                         isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
3166                         if ((lp->portid & 0xffff00) != 0) {
3167                                 (void) isp_plogx(isp, chan, lp->handle,
3168                                     lp->portid,
3169                                     PLOGX_FLG_CMD_LOGO |
3170                                     PLOGX_FLG_IMPLICIT |
3171                                     PLOGX_FLG_FREE_NPHDL);
3172                         }
3173                         /*
3174                          * Note that we might come out of this with our state
3175                          * set to FC_PORTDB_STATE_ZOMBIE.
3176                          */
3177                         break;
3178                 case FC_PORTDB_STATE_NEW:
3179                         lp->state = FC_PORTDB_STATE_VALID;
3180                         isp_async(isp, ISPASYNC_DEV_ARRIVED, chan, lp);
3181                         break;
3182                 case FC_PORTDB_STATE_CHANGED:
3183                         lp->state = FC_PORTDB_STATE_VALID;
3184                         isp_async(isp, ISPASYNC_DEV_CHANGED, chan, lp);
3185                         lp->portid = lp->new_portid;
3186                         lp->prli_word3 = lp->new_prli_word3;
3187                         break;
3188                 case FC_PORTDB_STATE_VALID:
3189                         isp_async(isp, ISPASYNC_DEV_STAYED, chan, lp);
3190                         break;
3191                 case FC_PORTDB_STATE_ZOMBIE:
3192                         break;
3193                 default:
3194                         isp_prt(isp, ISP_LOGWARN,
3195                             "isp_pdb_sync: state %d for idx %d",
3196                             lp->state, dbidx);
3197                         isp_dump_portdb(isp, chan);
3198                 }
3199         }
3200
3201         if (fcp->isp_loopstate < LOOP_SYNCING_PDB) {
3202                 isp_prt(isp, ISP_LOG_SANCFG,
3203                     "Chan %d FC PDB sync aborted", chan);
3204                 return (1);
3205         }
3206
3207         fcp->isp_loopstate = LOOP_READY;
3208         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync done", chan);
3209         return (0);
3210 }
3211
3212 static void
3213 isp_pdb_add_update(ispsoftc_t *isp, int chan, isp_pdb_t *pdb)
3214 {
3215         fcportdb_t *lp;
3216         uint64_t wwnn, wwpn;
3217
3218         MAKE_WWN_FROM_NODE_NAME(wwnn, pdb->nodename);
3219         MAKE_WWN_FROM_NODE_NAME(wwpn, pdb->portname);
3220
3221         /* Search port database for the same WWPN. */
3222         if (isp_find_pdb_by_wwpn(isp, chan, wwpn, &lp)) {
3223                 if (!lp->probational) {
3224                         isp_prt(isp, ISP_LOGERR,
3225                             "Chan %d Port 0x%06x@0x%04x [%d] is not probational (0x%x)",
3226                             chan, lp->portid, lp->handle,
3227                             FC_PORTDB_TGT(isp, chan, lp), lp->state);
3228                         isp_dump_portdb(isp, chan);
3229                         return;
3230                 }
3231                 lp->probational = 0;
3232                 lp->node_wwn = wwnn;
3233
3234                 /* Old device, nothing new. */
3235                 if (lp->portid == pdb->portid &&
3236                     lp->handle == pdb->handle &&
3237                     lp->prli_word3 == pdb->prli_word3) {
3238                         if (lp->state != FC_PORTDB_STATE_NEW)
3239                                 lp->state = FC_PORTDB_STATE_VALID;
3240                         isp_prt(isp, ISP_LOG_SANCFG,
3241                             "Chan %d Port 0x%06x@0x%04x is valid",
3242                             chan, pdb->portid, pdb->handle);
3243                         return;
3244                 }
3245
3246                 /* Something has changed. */
3247                 lp->state = FC_PORTDB_STATE_CHANGED;
3248                 lp->handle = pdb->handle;
3249                 lp->new_portid = pdb->portid;
3250                 lp->new_prli_word3 = pdb->prli_word3;
3251                 isp_prt(isp, ISP_LOG_SANCFG,
3252                     "Chan %d Port 0x%06x@0x%04x is changed",
3253                     chan, pdb->portid, pdb->handle);
3254                 return;
3255         }
3256
3257         /* It seems like a new port. Find an empty slot for it. */
3258         if (!isp_find_pdb_empty(isp, chan, &lp)) {
3259                 isp_prt(isp, ISP_LOGERR, "Chan %d out of portdb entries", chan);
3260                 return;
3261         }
3262
3263         ISP_MEMZERO(lp, sizeof (fcportdb_t));
3264         lp->probational = 0;
3265         lp->state = FC_PORTDB_STATE_NEW;
3266         lp->portid = lp->new_portid = pdb->portid;
3267         lp->prli_word3 = lp->new_prli_word3 = pdb->prli_word3;
3268         lp->handle = pdb->handle;
3269         lp->port_wwn = wwpn;
3270         lp->node_wwn = wwnn;
3271         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Port 0x%06x@0x%04x is new",
3272             chan, pdb->portid, pdb->handle);
3273 }
3274
3275 /*
3276  * Fix port IDs for logged-in initiators on pre-2400 chips.
3277  * For those chips we are not receiving login events, adding initiators
3278  * based on ATIO requests, but there is no port ID in that structure.
3279  */
3280 static void
3281 isp_fix_portids(ispsoftc_t *isp, int chan)
3282 {
3283         fcparam *fcp = FCPARAM(isp, chan);
3284         isp_pdb_t pdb;
3285         uint64_t wwpn;
3286         int i, r;
3287
3288         for (i = 0; i < MAX_FC_TARG; i++) {
3289                 fcportdb_t *lp = &fcp->portdb[i];
3290
3291                 if (lp->state == FC_PORTDB_STATE_NIL ||
3292                     lp->state == FC_PORTDB_STATE_ZOMBIE)
3293                         continue;
3294                 if (VALID_PORT(lp->portid))
3295                         continue;
3296
3297                 r = isp_getpdb(isp, chan, lp->handle, &pdb);
3298                 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3299                         return;
3300                 if (r != 0) {
3301                         isp_prt(isp, ISP_LOGDEBUG1,
3302                             "Chan %d FC Scan Loop handle %d returned %x",
3303                             chan, lp->handle, r);
3304                         continue;
3305                 }
3306
3307                 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3308                 if (lp->port_wwn != wwpn)
3309                         continue;
3310                 lp->portid = lp->new_portid = pdb.portid;
3311                 isp_prt(isp, ISP_LOG_SANCFG,
3312                     "Chan %d Port 0x%06x@0x%04x is fixed",
3313                     chan, pdb.portid, pdb.handle);
3314         }
3315 }
3316
3317 /*
3318  * Scan local loop for devices.
3319  */
3320 static int
3321 isp_scan_loop(ispsoftc_t *isp, int chan)
3322 {
3323         fcparam *fcp = FCPARAM(isp, chan);
3324         int idx, lim, r;
3325         isp_pdb_t pdb;
3326         uint16_t *handles;
3327         uint16_t handle;
3328
3329         if (fcp->isp_loopstate < LOOP_LTEST_DONE)
3330                 return (-1);
3331         if (fcp->isp_loopstate >= LOOP_LSCAN_DONE)
3332                 return (0);
3333
3334         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan", chan);
3335         fcp->isp_loopstate = LOOP_SCANNING_LOOP;
3336         if (TOPO_IS_FABRIC(fcp->isp_topo)) {
3337                 if (!IS_24XX(isp)) {
3338                         isp_fix_portids(isp, chan);
3339                         if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3340                                 goto abort;
3341                 }
3342                 isp_prt(isp, ISP_LOG_SANCFG,
3343                     "Chan %d FC loop scan done (no loop)", chan);
3344                 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3345                 return (0);
3346         }
3347
3348         handles = (uint16_t *)fcp->isp_scanscratch;
3349         lim = ISP_FC_SCRLEN / 2;
3350         r = isp_gethandles(isp, chan, handles, &lim, 1);
3351         if (r != 0) {
3352                 isp_prt(isp, ISP_LOG_SANCFG,
3353                     "Chan %d Getting list of handles failed with %x", chan, r);
3354                 isp_prt(isp, ISP_LOG_SANCFG,
3355                     "Chan %d FC loop scan done (bad)", chan);
3356                 return (-1);
3357         }
3358
3359         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Got %d handles",
3360             chan, lim);
3361
3362         /*
3363          * Run through the list and get the port database info for each one.
3364          */
3365         isp_mark_portdb(isp, chan);
3366         for (idx = 0; idx < lim; idx++) {
3367                 handle = handles[idx];
3368
3369                 /*
3370                  * Don't scan "special" ids.
3371                  */
3372                 if (ISP_CAP_2KLOGIN(isp)) {
3373                         if (handle >= NPH_RESERVED)
3374                                 continue;
3375                 } else {
3376                         if (handle >= FL_ID && handle <= SNS_ID)
3377                                 continue;
3378                 }
3379
3380                 /*
3381                  * In older cards with older f/w GET_PORT_DATABASE has been
3382                  * known to hang. This trick gets around that problem.
3383                  */
3384                 if (IS_2100(isp) || IS_2200(isp)) {
3385                         uint64_t node_wwn = isp_get_wwn(isp, chan, handle, 1);
3386                         if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
3387 abort:
3388                                 isp_prt(isp, ISP_LOG_SANCFG,
3389                                     "Chan %d FC loop scan aborted", chan);
3390                                 return (1);
3391                         }
3392                         if (node_wwn == INI_NONE) {
3393                                 continue;
3394                         }
3395                 }
3396
3397                 /*
3398                  * Get the port database entity for this index.
3399                  */
3400                 r = isp_getpdb(isp, chan, handle, &pdb);
3401                 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3402                         goto abort;
3403                 if (r != 0) {
3404                         isp_prt(isp, ISP_LOGDEBUG1,
3405                             "Chan %d FC Scan Loop handle %d returned %x",
3406                             chan, handle, r);
3407                         continue;
3408                 }
3409
3410                 isp_pdb_add_update(isp, chan, &pdb);
3411         }
3412         if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3413                 goto abort;
3414         fcp->isp_loopstate = LOOP_LSCAN_DONE;
3415         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan done", chan);
3416         return (0);
3417 }
3418
3419 static int
3420 isp_ct_sns(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
3421 {
3422         fcparam *fcp = FCPARAM(isp, chan);
3423         mbreg_t mbs;
3424
3425         if (isp->isp_dblev & ISP_LOGDEBUG1)
3426                 isp_print_bytes(isp, "CT SNS request", cmd_bcnt, fcp->isp_scratch);
3427         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, cmd_bcnt, chan);
3428
3429         MBSINIT(&mbs, MBOX_SEND_SNS, MBLOGALL, 10000000);
3430         mbs.param[1] = cmd_bcnt >> 1;
3431         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
3432         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
3433         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
3434         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
3435         isp_mboxcmd(isp, &mbs);
3436         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3437                 if (mbs.param[0] == MBOX_INVALID_COMMAND) {
3438                         return (1);
3439                 } else {
3440                         return (-1);
3441                 }
3442         }
3443
3444         MEMORYBARRIER(isp, SYNC_SFORCPU, 0, rsp_bcnt, chan);
3445         if (isp->isp_dblev & ISP_LOGDEBUG1)
3446                 isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
3447         return (0);
3448 }
3449
3450 static int
3451 isp_ct_passthru(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
3452 {
3453         fcparam *fcp = FCPARAM(isp, chan);
3454         isp_ct_pt_t pt;
3455         void *reqp;
3456         uint8_t resp[QENTRY_LEN];
3457
3458         if (isp->isp_dblev & ISP_LOGDEBUG1)
3459                 isp_print_bytes(isp, "CT request", cmd_bcnt, fcp->isp_scratch);
3460
3461         /*
3462          * Build a Passthrough IOCB in memory.
3463          */
3464         ISP_MEMZERO(&pt, sizeof(pt));
3465         pt.ctp_header.rqs_entry_count = 1;
3466         pt.ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
3467         pt.ctp_nphdl = fcp->isp_sns_hdl;
3468         pt.ctp_cmd_cnt = 1;
3469         pt.ctp_vpidx = ISP_GET_VPIDX(isp, chan);
3470         pt.ctp_time = 10;
3471         pt.ctp_rsp_cnt = 1;
3472         pt.ctp_rsp_bcnt = rsp_bcnt;
3473         pt.ctp_cmd_bcnt = cmd_bcnt;
3474         pt.ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma);
3475         pt.ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma);
3476         pt.ctp_dataseg[0].ds_count = cmd_bcnt;
3477         pt.ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma);
3478         pt.ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma);
3479         pt.ctp_dataseg[1].ds_count = rsp_bcnt;
3480
3481         /* Prepare space for response in memory */
3482         memset(resp, 0xff, sizeof(resp));
3483         pt.ctp_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
3484         if (pt.ctp_handle == 0) {
3485                 isp_prt(isp, ISP_LOGERR,
3486                     "%s: CTP of Chan %d out of handles", __func__, chan);
3487                 return (-1);
3488         }
3489
3490         /* Send request and wait for response. */
3491         reqp = isp_getrqentry(isp);
3492         if (reqp == NULL) {
3493                 isp_prt(isp, ISP_LOGERR,
3494                     "%s: CTP of Chan %d out of rqent", __func__, chan);
3495                 isp_destroy_handle(isp, pt.ctp_handle);
3496                 return (-1);
3497         }
3498         isp_put_ct_pt(isp, &pt, (isp_ct_pt_t *)reqp);
3499         if (isp->isp_dblev & ISP_LOGDEBUG1)
3500                 isp_print_bytes(isp, "CT IOCB request", QENTRY_LEN, reqp);
3501         ISP_SYNC_REQUEST(isp);
3502         if (msleep(resp, &isp->isp_lock, 0, "CTP", pt.ctp_time*hz) == EWOULDBLOCK) {
3503                 isp_prt(isp, ISP_LOGERR,
3504                     "%s: CTP of Chan %d timed out", __func__, chan);
3505                 isp_destroy_handle(isp, pt.ctp_handle);
3506                 return (-1);
3507         }
3508         if (isp->isp_dblev & ISP_LOGDEBUG1)
3509                 isp_print_bytes(isp, "CT IOCB response", QENTRY_LEN, resp);
3510
3511         isp_get_ct_pt(isp, (isp_ct_pt_t *)resp, &pt);
3512         if (pt.ctp_status && pt.ctp_status != RQCS_DATA_UNDERRUN) {
3513                 isp_prt(isp, ISP_LOGWARN,
3514                     "Chan %d CT pass-through returned 0x%x",
3515                     chan, pt.ctp_status);
3516                 return (-1);
3517         }
3518
3519         if (isp->isp_dblev & ISP_LOGDEBUG1)
3520                 isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
3521
3522         return (0);
3523 }
3524
3525 /*
3526  * Scan the fabric for devices and add them to our port database.
3527  *
3528  * Use the GID_PT command to get list of all Nx_Port IDs SNS knows.
3529  * Use GFF_ID and GFT_ID to check port type (FCP) and features (target).
3530  *
3531  * For 2100-23XX cards, we use the SNS mailbox command to pass simple name
3532  * server commands to the switch management server via the QLogic f/w.
3533  *
3534  * For the 24XX and above card, we use CT Pass-through IOCB.
3535  */
3536 #define GIDLEN  ISP_FC_SCRLEN
3537 #define NGENT   ((GIDLEN - 16) >> 2)
3538
3539 static int
3540 isp_gid_pt(ispsoftc_t *isp, int chan)
3541 {
3542         fcparam *fcp = FCPARAM(isp, chan);
3543         ct_hdr_t ct;
3544         sns_gid_pt_req_t rq;
3545         uint8_t *scp = fcp->isp_scratch;
3546
3547         isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GID_PT", chan);
3548         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3549                 isp_prt(isp, ISP_LOGERR, sacq);
3550                 return (-1);
3551         }
3552
3553         if (IS_24XX(isp)) {
3554                 /* Build the CT command and execute via pass-through. */
3555                 ISP_MEMZERO(&ct, sizeof (ct));
3556                 ct.ct_revision = CT_REVISION;
3557                 ct.ct_fcs_type = CT_FC_TYPE_FC;
3558                 ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3559                 ct.ct_cmd_resp = SNS_GID_PT;
3560                 ct.ct_bcnt_resid = (GIDLEN - 16) >> 2;
3561                 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3562                 scp[sizeof(ct)] = 0x7f;         /* Port Type = Nx_Port */
3563                 scp[sizeof(ct)+1] = 0;          /* Domain_ID = any */
3564                 scp[sizeof(ct)+2] = 0;          /* Area_ID = any */
3565                 scp[sizeof(ct)+3] = 0;          /* Flags = no Area_ID */
3566
3567                 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t), GIDLEN)) {
3568                         FC_SCRATCH_RELEASE(isp, chan);
3569                         return (-1);
3570                 }
3571         } else {
3572                 /* Build the SNS request and execute via firmware. */
3573                 ISP_MEMZERO(&rq, SNS_GID_PT_REQ_SIZE);
3574                 rq.snscb_rblen = GIDLEN >> 1;
3575                 rq.snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma);
3576                 rq.snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma);
3577                 rq.snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma);
3578                 rq.snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma);
3579                 rq.snscb_sblen = 6;
3580                 rq.snscb_cmd = SNS_GID_PT;
3581                 rq.snscb_mword_div_2 = NGENT;
3582                 rq.snscb_port_type = 0x7f;      /* Port Type = Nx_Port */
3583                 rq.snscb_domain = 0;            /* Domain_ID = any */
3584                 rq.snscb_area = 0;              /* Area_ID = any */
3585                 rq.snscb_flags = 0;             /* Flags = no Area_ID */
3586                 isp_put_gid_pt_request(isp, &rq, (sns_gid_pt_req_t *)scp);
3587
3588                 if (isp_ct_sns(isp, chan, sizeof(rq), NGENT)) {
3589                         FC_SCRATCH_RELEASE(isp, chan);
3590                         return (-1);
3591                 }
3592         }
3593
3594         isp_get_gid_xx_response(isp, (sns_gid_xx_rsp_t *)scp,
3595             (sns_gid_xx_rsp_t *)fcp->isp_scanscratch, NGENT);
3596         FC_SCRATCH_RELEASE(isp, chan);
3597         return (0);
3598 }
3599
3600 static int
3601 isp_gff_id(ispsoftc_t *isp, int chan, uint32_t portid)
3602 {
3603         fcparam *fcp = FCPARAM(isp, chan);
3604         ct_hdr_t ct;
3605         uint32_t *rp;
3606         uint8_t *scp = fcp->isp_scratch;
3607         sns_gff_id_rsp_t rsp;
3608         int i, res = -1;
3609
3610         if (!fcp->isp_use_gff_id)       /* User may block GFF_ID use. */
3611                 return (res);
3612
3613         if (!IS_24XX(isp))      /* Old chips can't request GFF_ID. */
3614                 return (res);
3615
3616         isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFF_ID", chan);
3617         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3618                 isp_prt(isp, ISP_LOGERR, sacq);
3619                 return (res);
3620         }
3621
3622         /* Build the CT command and execute via pass-through. */
3623         ISP_MEMZERO(&ct, sizeof (ct));
3624         ct.ct_revision = CT_REVISION;
3625         ct.ct_fcs_type = CT_FC_TYPE_FC;
3626         ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3627         ct.ct_cmd_resp = SNS_GFF_ID;
3628         ct.ct_bcnt_resid = (SNS_GFF_ID_RESP_SIZE - sizeof(ct)) / 4;
3629         isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3630         rp = (uint32_t *) &scp[sizeof(ct)];
3631         ISP_IOZPUT_32(isp, portid, rp);
3632
3633         if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
3634             SNS_GFF_ID_RESP_SIZE)) {
3635                 FC_SCRATCH_RELEASE(isp, chan);
3636                 return (res);
3637         }
3638
3639         isp_get_gff_id_response(isp, (sns_gff_id_rsp_t *)scp, &rsp);
3640         if (rsp.snscb_cthdr.ct_cmd_resp == LS_ACC) {
3641                 for (i = 0; i < 32; i++) {
3642                         if (rsp.snscb_fc4_features[i] != 0) {
3643                                 res = 0;
3644                                 break;
3645                         }
3646                 }
3647                 if (((rsp.snscb_fc4_features[FC4_SCSI / 8] >>
3648                     ((FC4_SCSI % 8) * 4)) & 0x01) != 0)
3649                         res = 1;
3650                 /* Workaround for broken Brocade firmware. */
3651                 if (((ISP_SWAP32(isp, rsp.snscb_fc4_features[FC4_SCSI / 8]) >>
3652                     ((FC4_SCSI % 8) * 4)) & 0x01) != 0)
3653                         res = 1;
3654         }
3655         FC_SCRATCH_RELEASE(isp, chan);
3656         isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFF_ID result is %d", chan, res);
3657         return (res);
3658 }
3659
3660 static int
3661 isp_gft_id(ispsoftc_t *isp, int chan, uint32_t portid)
3662 {
3663         fcparam *fcp = FCPARAM(isp, chan);
3664         ct_hdr_t ct;
3665         sns_gxx_id_req_t rq;
3666         uint32_t *rp;
3667         uint8_t *scp = fcp->isp_scratch;
3668         sns_gft_id_rsp_t rsp;
3669         int i, res = -1;
3670
3671         if (!fcp->isp_use_gft_id)       /* User may block GFT_ID use. */
3672                 return (res);
3673
3674         isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFT_ID", chan);
3675         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3676                 isp_prt(isp, ISP_LOGERR, sacq);
3677                 return (res);
3678         }
3679
3680         if (IS_24XX(isp)) {
3681                 /* Build the CT command and execute via pass-through. */
3682                 ISP_MEMZERO(&ct, sizeof (ct));
3683                 ct.ct_revision = CT_REVISION;
3684                 ct.ct_fcs_type = CT_FC_TYPE_FC;
3685                 ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3686                 ct.ct_cmd_resp = SNS_GFT_ID;
3687                 ct.ct_bcnt_resid = (SNS_GFT_ID_RESP_SIZE - sizeof(ct)) / 4;
3688                 isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3689                 rp = (uint32_t *) &scp[sizeof(ct)];
3690                 ISP_IOZPUT_32(isp, portid, rp);
3691
3692                 if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
3693                     SNS_GFT_ID_RESP_SIZE)) {
3694                         FC_SCRATCH_RELEASE(isp, chan);
3695                         return (res);
3696                 }
3697         } else {
3698                 /* Build the SNS request and execute via firmware. */
3699                 ISP_MEMZERO(&rq, SNS_GXX_ID_REQ_SIZE);
3700                 rq.snscb_rblen = SNS_GFT_ID_RESP_SIZE >> 1;
3701                 rq.snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma);
3702                 rq.snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma);
3703                 rq.snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma);
3704                 rq.snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma);
3705                 rq.snscb_sblen = 6;
3706                 rq.snscb_cmd = SNS_GFT_ID;
3707                 rq.snscb_mword_div_2 = (SNS_GFT_ID_RESP_SIZE - sizeof(ct)) / 4;
3708                 rq.snscb_portid = portid;
3709                 isp_put_gxx_id_request(isp, &rq, (sns_gxx_id_req_t *)scp);
3710
3711                 if (isp_ct_sns(isp, chan, sizeof(rq), SNS_GFT_ID_RESP_SIZE)) {
3712                         FC_SCRATCH_RELEASE(isp, chan);
3713                         return (res);
3714                 }
3715         }
3716
3717         isp_get_gft_id_response(isp, (sns_gft_id_rsp_t *)scp, &rsp);
3718         if (rsp.snscb_cthdr.ct_cmd_resp == LS_ACC) {
3719                 for (i = 0; i < 8; i++) {
3720                         if (rsp.snscb_fc4_types[i] != 0) {
3721                                 res = 0;
3722                                 break;
3723                         }
3724                 }
3725                 if (((rsp.snscb_fc4_types[FC4_SCSI / 32] >>
3726                     (FC4_SCSI % 32)) & 0x01) != 0)
3727                         res = 1;
3728         }
3729         FC_SCRATCH_RELEASE(isp, chan);
3730         isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFT_ID result is %d", chan, res);
3731         return (res);
3732 }
3733
3734 static int
3735 isp_scan_fabric(ispsoftc_t *isp, int chan)
3736 {
3737         fcparam *fcp = FCPARAM(isp, chan);
3738         fcportdb_t *lp;
3739         uint32_t portid;
3740         uint16_t nphdl;
3741         isp_pdb_t pdb;
3742         int portidx, portlim, r;
3743         sns_gid_xx_rsp_t *rs;
3744
3745         if (fcp->isp_loopstate < LOOP_LSCAN_DONE)
3746                 return (-1);
3747         if (fcp->isp_loopstate >= LOOP_FSCAN_DONE)
3748                 return (0);
3749
3750         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan", chan);
3751         fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
3752         if (!TOPO_IS_FABRIC(fcp->isp_topo)) {
3753                 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3754                 isp_prt(isp, ISP_LOG_SANCFG,
3755                     "Chan %d FC fabric scan done (no fabric)", chan);
3756                 return (0);
3757         }
3758
3759         if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC) {
3760 abort:
3761                 FC_SCRATCH_RELEASE(isp, chan);
3762                 isp_prt(isp, ISP_LOG_SANCFG,
3763                     "Chan %d FC fabric scan aborted", chan);
3764                 return (1);
3765         }
3766
3767         /*
3768          * Make sure we still are logged into the fabric controller.
3769          */
3770         nphdl = IS_24XX(isp) ? NPH_FL_ID : FL_ID;
3771         r = isp_getpdb(isp, chan, nphdl, &pdb);
3772         if ((r & 0xffff) == MBOX_NOT_LOGGED_IN) {
3773                 isp_dump_chip_portdb(isp, chan);
3774         }
3775         if (r) {
3776                 fcp->isp_loopstate = LOOP_LTEST_DONE;
3777 fail:
3778                 isp_prt(isp, ISP_LOG_SANCFG,
3779                     "Chan %d FC fabric scan done (bad)", chan);
3780                 return (-1);
3781         }
3782
3783         /* Get list of port IDs from SNS. */
3784         r = isp_gid_pt(isp, chan);
3785         if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3786                 goto abort;
3787         if (r > 0) {
3788                 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3789                 return (-1);
3790         } else if (r < 0) {
3791                 fcp->isp_loopstate = LOOP_LTEST_DONE;   /* try again */
3792                 return (-1);
3793         }
3794
3795         rs = (sns_gid_xx_rsp_t *) fcp->isp_scanscratch;
3796         if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3797                 goto abort;
3798         if (rs->snscb_cthdr.ct_cmd_resp != LS_ACC) {
3799                 int level;
3800                 /* FC-4 Type and Port Type not registered are not errors. */
3801                 if (rs->snscb_cthdr.ct_reason == 9 &&
3802                     (rs->snscb_cthdr.ct_explanation == 0x07 ||
3803                      rs->snscb_cthdr.ct_explanation == 0x0a)) {
3804                         level = ISP_LOG_SANCFG;
3805                 } else {
3806                         level = ISP_LOGWARN;
3807                 }
3808                 isp_prt(isp, level, "Chan %d Fabric Nameserver rejected GID_PT"
3809                     " (Reason=0x%x Expl=0x%x)", chan,
3810                     rs->snscb_cthdr.ct_reason,
3811                     rs->snscb_cthdr.ct_explanation);
3812                 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3813                 return (-1);
3814         }
3815
3816         /* Check our buffer was big enough to get the full list. */
3817         for (portidx = 0; portidx < NGENT-1; portidx++) {
3818                 if (rs->snscb_ports[portidx].control & 0x80)
3819                         break;
3820         }
3821         if ((rs->snscb_ports[portidx].control & 0x80) == 0) {
3822                 isp_prt(isp, ISP_LOGWARN,
3823                     "fabric too big for scratch area: increase ISP_FC_SCRLEN");
3824         }
3825         portlim = portidx + 1;
3826         isp_prt(isp, ISP_LOG_SANCFG,
3827             "Chan %d Got %d ports back from name server", chan, portlim);
3828
3829         /* Go through the list and remove duplicate port ids. */
3830         for (portidx = 0; portidx < portlim; portidx++) {
3831                 int npidx;
3832
3833                 portid =
3834                     ((rs->snscb_ports[portidx].portid[0]) << 16) |
3835                     ((rs->snscb_ports[portidx].portid[1]) << 8) |
3836                     ((rs->snscb_ports[portidx].portid[2]));
3837
3838                 for (npidx = portidx + 1; npidx < portlim; npidx++) {
3839                         uint32_t new_portid =
3840                             ((rs->snscb_ports[npidx].portid[0]) << 16) |
3841                             ((rs->snscb_ports[npidx].portid[1]) << 8) |
3842                             ((rs->snscb_ports[npidx].portid[2]));
3843                         if (new_portid == portid) {
3844                                 break;
3845                         }
3846                 }
3847
3848                 if (npidx < portlim) {
3849                         rs->snscb_ports[npidx].portid[0] = 0;
3850                         rs->snscb_ports[npidx].portid[1] = 0;
3851                         rs->snscb_ports[npidx].portid[2] = 0;
3852                         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d removing duplicate PortID 0x%06x entry from list", chan, portid);
3853                 }
3854         }
3855
3856         /*
3857          * We now have a list of Port IDs for all FC4 SCSI devices
3858          * that the Fabric Name server knows about.
3859          *
3860          * For each entry on this list go through our port database looking
3861          * for probational entries- if we find one, then an old entry is
3862          * maybe still this one. We get some information to find out.
3863          *
3864          * Otherwise, it's a new fabric device, and we log into it
3865          * (unconditionally). After searching the entire database
3866          * again to make sure that we never ever ever ever have more
3867          * than one entry that has the same PortID or the same
3868          * WWNN/WWPN duple, we enter the device into our database.
3869          */
3870         isp_mark_portdb(isp, chan);
3871         for (portidx = 0; portidx < portlim; portidx++) {
3872                 portid = ((rs->snscb_ports[portidx].portid[0]) << 16) |
3873                          ((rs->snscb_ports[portidx].portid[1]) << 8) |
3874                          ((rs->snscb_ports[portidx].portid[2]));
3875                 isp_prt(isp, ISP_LOG_SANCFG,
3876                     "Chan %d Checking fabric port 0x%06x", chan, portid);
3877                 if (portid == 0) {
3878                         isp_prt(isp, ISP_LOG_SANCFG,
3879                             "Chan %d Port at idx %d is zero",
3880                             chan, portidx);
3881                         continue;
3882                 }
3883                 if (portid == fcp->isp_portid) {
3884                         isp_prt(isp, ISP_LOG_SANCFG,
3885                             "Chan %d Port 0x%06x is our", chan, portid);
3886                         continue;
3887                 }
3888
3889                 /* Now search the entire port database for the same portid. */
3890                 if (isp_find_pdb_by_portid(isp, chan, portid, &lp)) {
3891                         if (!lp->probational) {
3892                                 isp_prt(isp, ISP_LOGERR,
3893                                     "Chan %d Port 0x%06x@0x%04x [%d] is not probational (0x%x)",
3894                                     chan, lp->portid, lp->handle,
3895                                     FC_PORTDB_TGT(isp, chan, lp), lp->state);
3896                                 isp_dump_portdb(isp, chan);
3897                                 goto fail;
3898                         }
3899
3900                         if (lp->state == FC_PORTDB_STATE_ZOMBIE)
3901                                 goto relogin;
3902
3903                         /*
3904                          * See if we're still logged into it.
3905                          *
3906                          * If we aren't, mark it as a dead device and
3907                          * leave the new portid in the database entry
3908                          * for somebody further along to decide what to
3909                          * do (policy choice).
3910                          *
3911                          * If we are, check to see if it's the same
3912                          * device still (it should be). If for some
3913                          * reason it isn't, mark it as a changed device
3914                          * and leave the new portid and role in the
3915                          * database entry for somebody further along to
3916                          * decide what to do (policy choice).
3917                          */
3918                         r = isp_getpdb(isp, chan, lp->handle, &pdb);
3919                         if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3920                                 goto abort;
3921                         if (r != 0) {
3922                                 lp->state = FC_PORTDB_STATE_DEAD;
3923                                 isp_prt(isp, ISP_LOG_SANCFG,
3924                                     "Chan %d Port 0x%06x handle 0x%x is dead (%d)",
3925                                     chan, portid, lp->handle, r);
3926                                 goto relogin;
3927                         }
3928
3929                         isp_pdb_add_update(isp, chan, &pdb);
3930                         continue;
3931                 }
3932
3933 relogin:
3934                 if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
3935                         isp_prt(isp, ISP_LOG_SANCFG,
3936                             "Chan %d Port 0x%06x is not logged in", chan, portid);
3937                         continue;
3938                 }
3939
3940                 r = isp_gff_id(isp, chan, portid);
3941                 if (r == 0) {
3942                         isp_prt(isp, ISP_LOG_SANCFG,
3943                             "Chan %d Port 0x%06x is not an FCP target", chan, portid);
3944                         continue;
3945                 }
3946                 if (r < 0)
3947                         r = isp_gft_id(isp, chan, portid);
3948                 if (r == 0) {
3949                         isp_prt(isp, ISP_LOG_SANCFG,
3950                             "Chan %d Port 0x%06x is not FCP", chan, portid);
3951                         continue;
3952                 }
3953
3954                 if (isp_login_device(isp, chan, portid, &pdb,
3955                     &FCPARAM(isp, 0)->isp_lasthdl)) {
3956                         if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3957                                 goto abort;
3958                         continue;
3959                 }
3960
3961                 isp_pdb_add_update(isp, chan, &pdb);
3962         }
3963
3964         if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3965                 goto abort;
3966         fcp->isp_loopstate = LOOP_FSCAN_DONE;
3967         isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan done", chan);
3968         return (0);
3969 }
3970
3971 /*
3972  * Find an unused handle and try and use to login to a port.
3973  */
3974 static int
3975 isp_login_device(ispsoftc_t *isp, int chan, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)
3976 {
3977         int lim, i, r;
3978         uint16_t handle;
3979
3980         if (ISP_CAP_2KLOGIN(isp)) {
3981                 lim = NPH_MAX_2K;
3982         } else {
3983                 lim = NPH_MAX;
3984         }
3985
3986         handle = isp_next_handle(isp, ohp);
3987         for (i = 0; i < lim; i++) {
3988                 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
3989                         return (-1);
3990
3991                 /* Check if this handle is free. */
3992                 r = isp_getpdb(isp, chan, handle, p);
3993                 if (r == 0) {
3994                         if (p->portid != portid) {
3995                                 /* This handle is busy, try next one. */
3996                                 handle = isp_next_handle(isp, ohp);
3997                                 continue;
3998                         }
3999                         break;
4000                 }
4001                 if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
4002                         return (-1);
4003
4004                 /*
4005                  * Now try and log into the device
4006                  */
4007                 r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
4008                 if (r == 0) {
4009                         break;
4010                 } else if ((r & 0xffff) == MBOX_PORT_ID_USED) {
4011                         /*
4012                          * If we get here, then the firmwware still thinks we're logged into this device, but with a different
4013                          * handle. We need to break that association. We used to try and just substitute the handle, but then
4014                          * failed to get any data via isp_getpdb (below).
4015                          */
4016                         if (isp_plogx(isp, chan, r >> 16, portid, PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT | PLOGX_FLG_FREE_NPHDL)) {
4017                                 isp_prt(isp, ISP_LOGERR, "baw... logout of %x failed", r >> 16);
4018                         }
4019                         if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
4020                                 return (-1);
4021                         r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
4022                         if (r != 0)
4023                                 i = lim;
4024                         break;
4025                 } else if ((r & 0xffff) == MBOX_LOOP_ID_USED) {
4026                         /* Try the next handle. */
4027                         handle = isp_next_handle(isp, ohp);
4028                 } else {
4029                         /* Give up. */
4030                         i = lim;
4031                         break;
4032                 }
4033         }
4034
4035         if (i == lim) {
4036                 isp_prt(isp, ISP_LOGWARN, "Chan %d PLOGI 0x%06x failed", chan, portid);
4037                 return (-1);
4038         }
4039
4040         /*
4041          * If we successfully logged into it, get the PDB for it
4042          * so we can crosscheck that it is still what we think it
4043          * is and that we also have the role it plays
4044          */
4045         r = isp_getpdb(isp, chan, handle, p);
4046         if (r != 0) {
4047                 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x disappeared", chan, portid, handle);
4048                 return (-1);
4049         }
4050
4051         if (p->handle != handle || p->portid != portid) {
4052                 isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
4053                     chan, portid, handle, p->portid, p->handle);
4054                 return (-1);
4055         }
4056         return (0);
4057 }
4058
4059 static int
4060 isp_send_change_request(ispsoftc_t *isp, int chan)
4061 {
4062         mbreg_t mbs;
4063
4064         MBSINIT(&mbs, MBOX_SEND_CHANGE_REQUEST, MBLOGALL, 500000);
4065         mbs.param[1] = 0x03;
4066         mbs.param[9] = chan;
4067         isp_mboxcmd(isp, &mbs);
4068         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
4069                 return (0);
4070         } else {
4071                 isp_prt(isp, ISP_LOGWARN, "Chan %d Send Change Request: 0x%x",
4072                     chan, mbs.param[0]);
4073                 return (-1);
4074         }
4075 }
4076
4077 static int
4078 isp_register_fc4_type(ispsoftc_t *isp, int chan)
4079 {
4080         fcparam *fcp = FCPARAM(isp, chan);
4081         rft_id_t rp;
4082         ct_hdr_t *ct = &rp.rftid_hdr;
4083         uint8_t local[SNS_RFT_ID_REQ_SIZE];
4084         sns_screq_t *reqp = (sns_screq_t *) local;
4085         uint8_t *scp = fcp->isp_scratch;
4086
4087         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4088                 isp_prt(isp, ISP_LOGERR, sacq);
4089                 return (-1);
4090         }
4091
4092         if (IS_24XX(isp)) {
4093                 /* Build the CT command and execute via pass-through. */
4094                 ISP_MEMZERO(&rp, sizeof(rp));
4095                 ct->ct_revision = CT_REVISION;
4096                 ct->ct_fcs_type = CT_FC_TYPE_FC;
4097                 ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4098                 ct->ct_cmd_resp = SNS_RFT_ID;
4099                 ct->ct_bcnt_resid = (sizeof (rft_id_t) - sizeof (ct_hdr_t)) >> 2;
4100                 rp.rftid_portid[0] = fcp->isp_portid >> 16;
4101                 rp.rftid_portid[1] = fcp->isp_portid >> 8;
4102                 rp.rftid_portid[2] = fcp->isp_portid;
4103                 rp.rftid_fc4types[FC4_SCSI >> 5] = 1 << (FC4_SCSI & 0x1f);
4104                 isp_put_rft_id(isp, &rp, (rft_id_t *)scp);
4105
4106                 if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
4107                         FC_SCRATCH_RELEASE(isp, chan);
4108                         return (-1);
4109                 }
4110         } else {
4111                 /* Build the SNS request and execute via firmware. */
4112                 ISP_MEMZERO((void *) reqp, SNS_RFT_ID_REQ_SIZE);
4113                 reqp->snscb_rblen = sizeof (ct_hdr_t) >> 1;
4114                 reqp->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma);
4115                 reqp->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma);
4116                 reqp->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma);
4117                 reqp->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma);
4118                 reqp->snscb_sblen = 22;
4119                 reqp->snscb_data[0] = SNS_RFT_ID;
4120                 reqp->snscb_data[4] = fcp->isp_portid & 0xffff;
4121                 reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff;
4122                 reqp->snscb_data[6] = (1 << FC4_SCSI);
4123                 isp_put_sns_request(isp, reqp, (sns_screq_t *)scp);
4124
4125                 if (isp_ct_sns(isp, chan, SNS_RFT_ID_REQ_SIZE, sizeof(ct_hdr_t))) {
4126                         FC_SCRATCH_RELEASE(isp, chan);
4127                         return (-1);
4128                 }
4129         }
4130
4131         isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4132         FC_SCRATCH_RELEASE(isp, chan);
4133         if (ct->ct_cmd_resp == LS_RJT) {
4134                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "Chan %d Register FC4 Type rejected", chan);
4135                 return (-1);
4136         } else if (ct->ct_cmd_resp == LS_ACC) {
4137                 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Register FC4 Type accepted", chan);
4138         } else {
4139                 isp_prt(isp, ISP_LOGWARN, "Chan %d Register FC4 Type: 0x%x", chan, ct->ct_cmd_resp);
4140                 return (-1);
4141         }
4142         return (0);
4143 }
4144
4145 static int
4146 isp_register_fc4_features_24xx(ispsoftc_t *isp, int chan)
4147 {
4148         fcparam *fcp = FCPARAM(isp, chan);
4149         ct_hdr_t *ct;
4150         rff_id_t rp;
4151         uint8_t *scp = fcp->isp_scratch;
4152
4153         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4154                 isp_prt(isp, ISP_LOGERR, sacq);
4155                 return (-1);
4156         }
4157
4158         /*
4159          * Build the CT header and command in memory.
4160          */
4161         ISP_MEMZERO(&rp, sizeof(rp));
4162         ct = &rp.rffid_hdr;
4163         ct->ct_revision = CT_REVISION;
4164         ct->ct_fcs_type = CT_FC_TYPE_FC;
4165         ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4166         ct->ct_cmd_resp = SNS_RFF_ID;
4167         ct->ct_bcnt_resid = (sizeof (rff_id_t) - sizeof (ct_hdr_t)) >> 2;
4168         rp.rffid_portid[0] = fcp->isp_portid >> 16;
4169         rp.rffid_portid[1] = fcp->isp_portid >> 8;
4170         rp.rffid_portid[2] = fcp->isp_portid;
4171         rp.rffid_fc4features = 0;
4172         if (fcp->role & ISP_ROLE_TARGET)
4173                 rp.rffid_fc4features |= 1;
4174         if (fcp->role & ISP_ROLE_INITIATOR)
4175                 rp.rffid_fc4features |= 2;
4176         rp.rffid_fc4type = FC4_SCSI;
4177         isp_put_rff_id(isp, &rp, (rff_id_t *)scp);
4178         if (isp->isp_dblev & ISP_LOGDEBUG1)
4179                 isp_print_bytes(isp, "CT request", sizeof(rft_id_t), scp);
4180
4181         if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
4182                 FC_SCRATCH_RELEASE(isp, chan);
4183                 return (-1);
4184         }
4185
4186         isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4187         FC_SCRATCH_RELEASE(isp, chan);
4188         if (ct->ct_cmd_resp == LS_RJT) {
4189                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4190                     "Chan %d Register FC4 Features rejected", chan);
4191                 return (-1);
4192         } else if (ct->ct_cmd_resp == LS_ACC) {
4193                 isp_prt(isp, ISP_LOG_SANCFG,
4194                     "Chan %d Register FC4 Features accepted", chan);
4195         } else {
4196                 isp_prt(isp, ISP_LOGWARN,
4197                     "Chan %d Register FC4 Features: 0x%x", chan, ct->ct_cmd_resp);
4198                 return (-1);
4199         }
4200         return (0);
4201 }
4202
4203 static int
4204 isp_register_port_name_24xx(ispsoftc_t *isp, int chan)
4205 {
4206         fcparam *fcp = FCPARAM(isp, chan);
4207         ct_hdr_t *ct;
4208         rspn_id_t rp;
4209         uint8_t *scp = fcp->isp_scratch;
4210         int len;
4211
4212         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4213                 isp_prt(isp, ISP_LOGERR, sacq);
4214                 return (-1);
4215         }
4216
4217         /*
4218          * Build the CT header and command in memory.
4219          */
4220         ISP_MEMZERO(&rp, sizeof(rp));
4221         ct = &rp.rspnid_hdr;
4222         ct->ct_revision = CT_REVISION;
4223         ct->ct_fcs_type = CT_FC_TYPE_FC;
4224         ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4225         ct->ct_cmd_resp = SNS_RSPN_ID;
4226         rp.rspnid_portid[0] = fcp->isp_portid >> 16;
4227         rp.rspnid_portid[1] = fcp->isp_portid >> 8;
4228         rp.rspnid_portid[2] = fcp->isp_portid;
4229         rp.rspnid_length = 0;
4230         len = offsetof(rspn_id_t, rspnid_name);
4231         mtx_lock(&prison0.pr_mtx);
4232         rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
4233             "%s", prison0.pr_hostname[0] ? prison0.pr_hostname : "FreeBSD");
4234         mtx_unlock(&prison0.pr_mtx);
4235         rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
4236             ":%s", device_get_nameunit(isp->isp_dev));
4237         if (chan != 0) {
4238                 rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
4239                     "/%d", chan);
4240         }
4241         len += rp.rspnid_length;
4242         ct->ct_bcnt_resid = (len - sizeof(ct_hdr_t)) >> 2;
4243         isp_put_rspn_id(isp, &rp, (rspn_id_t *)scp);
4244
4245         if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
4246                 FC_SCRATCH_RELEASE(isp, chan);
4247                 return (-1);
4248         }
4249
4250         isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4251         FC_SCRATCH_RELEASE(isp, chan);
4252         if (ct->ct_cmd_resp == LS_RJT) {
4253                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4254                     "Chan %d Register Symbolic Port Name rejected", chan);
4255                 return (-1);
4256         } else if (ct->ct_cmd_resp == LS_ACC) {
4257                 isp_prt(isp, ISP_LOG_SANCFG,
4258                     "Chan %d Register Symbolic Port Name accepted", chan);
4259         } else {
4260                 isp_prt(isp, ISP_LOGWARN,
4261                     "Chan %d Register Symbolic Port Name: 0x%x", chan, ct->ct_cmd_resp);
4262                 return (-1);
4263         }
4264         return (0);
4265 }
4266
4267 static int
4268 isp_register_node_name_24xx(ispsoftc_t *isp, int chan)
4269 {
4270         fcparam *fcp = FCPARAM(isp, chan);
4271         ct_hdr_t *ct;
4272         rsnn_nn_t rp;
4273         uint8_t *scp = fcp->isp_scratch;
4274         int len;
4275
4276         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4277                 isp_prt(isp, ISP_LOGERR, sacq);
4278                 return (-1);
4279         }
4280
4281         /*
4282          * Build the CT header and command in memory.
4283          */
4284         ISP_MEMZERO(&rp, sizeof(rp));
4285         ct = &rp.rsnnnn_hdr;
4286         ct->ct_revision = CT_REVISION;
4287         ct->ct_fcs_type = CT_FC_TYPE_FC;
4288         ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4289         ct->ct_cmd_resp = SNS_RSNN_NN;
4290         MAKE_NODE_NAME_FROM_WWN(rp.rsnnnn_nodename, fcp->isp_wwnn);
4291         rp.rsnnnn_length = 0;
4292         len = offsetof(rsnn_nn_t, rsnnnn_name);
4293         mtx_lock(&prison0.pr_mtx);
4294         rp.rsnnnn_length += sprintf(&scp[len + rp.rsnnnn_length],
4295             "%s", prison0.pr_hostname[0] ? prison0.pr_hostname : "FreeBSD");
4296         mtx_unlock(&prison0.pr_mtx);
4297         len += rp.rsnnnn_length;
4298         ct->ct_bcnt_resid = (len - sizeof(ct_hdr_t)) >> 2;
4299         isp_put_rsnn_nn(isp, &rp, (rsnn_nn_t *)scp);
4300
4301         if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
4302                 FC_SCRATCH_RELEASE(isp, chan);
4303                 return (-1);
4304         }
4305
4306         isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4307         FC_SCRATCH_RELEASE(isp, chan);
4308         if (ct->ct_cmd_resp == LS_RJT) {
4309                 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4310                     "Chan %d Register Symbolic Node Name rejected", chan);
4311                 return (-1);
4312         } else if (ct->ct_cmd_resp == LS_ACC) {
4313                 isp_prt(isp, ISP_LOG_SANCFG,
4314                     "Chan %d Register Symbolic Node Name accepted", chan);
4315         } else {
4316                 isp_prt(isp, ISP_LOGWARN,
4317                     "Chan %d Register Symbolic Node Name: 0x%x", chan, ct->ct_cmd_resp);
4318                 return (-1);
4319         }
4320         return (0);
4321 }
4322
4323 static uint16_t
4324 isp_next_handle(ispsoftc_t *isp, uint16_t *ohp)
4325 {
4326         fcparam *fcp;
4327         int i, chan, wrap;
4328         uint16_t handle, minh, maxh;
4329
4330         handle = *ohp;
4331         if (ISP_CAP_2KLOGIN(isp)) {
4332                 minh = 0;
4333                 maxh = NPH_RESERVED - 1;
4334         } else {
4335                 minh = SNS_ID + 1;
4336                 maxh = NPH_MAX - 1;
4337         }
4338         wrap = 0;
4339
4340 next:
4341         if (handle == NIL_HANDLE) {
4342                 handle = minh;
4343         } else {
4344                 handle++;
4345                 if (handle > maxh) {
4346                         if (++wrap >= 2) {
4347                                 isp_prt(isp, ISP_LOGERR, "Out of port handles!");
4348                                 return (NIL_HANDLE);
4349                         }
4350                         handle = minh;
4351                 }
4352         }
4353         for (chan = 0; chan < isp->isp_nchan; chan++) {
4354                 fcp = FCPARAM(isp, chan);
4355                 if (fcp->role == ISP_ROLE_NONE)
4356                         continue;
4357                 for (i = 0; i < MAX_FC_TARG; i++) {
4358                         if (fcp->portdb[i].state != FC_PORTDB_STATE_NIL &&
4359                             fcp->portdb[i].handle == handle)
4360                                 goto next;
4361                 }
4362         }
4363         *ohp = handle;
4364         return (handle);
4365 }
4366
4367 /*
4368  * Start a command. Locking is assumed done in the caller.
4369  */
4370
4371 int
4372 isp_start(XS_T *xs)
4373 {
4374         ispsoftc_t *isp;
4375         uint32_t cdblen;
4376         uint8_t local[QENTRY_LEN];
4377         ispreq_t *reqp;
4378         void *cdbp, *qep;
4379         uint16_t *tptr;
4380         fcportdb_t *lp;
4381         int target, dmaresult;
4382
4383         XS_INITERR(xs);
4384         isp = XS_ISP(xs);
4385
4386         /*
4387          * Check command CDB length, etc.. We really are limited to 16 bytes
4388          * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
4389          * but probably only if we're running fairly new firmware (we'll
4390          * let the old f/w choke on an extended command queue entry).
4391          */
4392
4393         if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
4394                 isp_prt(isp, ISP_LOGERR, "unsupported cdb length (%d, CDB[0]=0x%x)", XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
4395                 XS_SETERR(xs, HBA_REQINVAL);
4396                 return (CMD_COMPLETE);
4397         }
4398
4399         /*
4400          * Translate the target to device handle as appropriate, checking
4401          * for correct device state as well.
4402          */
4403         target = XS_TGT(xs);
4404         if (IS_FC(isp)) {
4405                 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
4406
4407                 if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
4408                         isp_prt(isp, ISP_LOG_WARN1,
4409                             "%d.%d.%jx I am not an initiator",
4410                             XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4411                         XS_SETERR(xs, HBA_SELTIMEOUT);
4412                         return (CMD_COMPLETE);
4413                 }
4414
4415                 if (isp->isp_state != ISP_RUNSTATE) {
4416                         isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4417                         XS_SETERR(xs, HBA_BOTCH);
4418                         return (CMD_COMPLETE);
4419                 }
4420
4421                 isp_prt(isp, ISP_LOGDEBUG2, "XS_TGT(xs)=%d", target);
4422                 lp = &fcp->portdb[target];
4423                 if (target < 0 || target >= MAX_FC_TARG ||
4424                     lp->is_target == 0) {
4425                         XS_SETERR(xs, HBA_SELTIMEOUT);
4426                         return (CMD_COMPLETE);
4427                 }
4428                 if (fcp->isp_loopstate != LOOP_READY) {
4429                         isp_prt(isp, ISP_LOGDEBUG1,
4430                             "%d.%d.%jx loop is not ready",
4431                             XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4432                         return (CMD_RQLATER);
4433                 }
4434                 if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
4435                         isp_prt(isp, ISP_LOGDEBUG1,
4436                             "%d.%d.%jx target zombie",
4437                             XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4438                         return (CMD_RQLATER);
4439                 }
4440                 if (lp->state != FC_PORTDB_STATE_VALID) {
4441                         isp_prt(isp, ISP_LOGDEBUG1,
4442                             "%d.%d.%jx bad db port state 0x%x",
4443                             XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs), lp->state);
4444                         XS_SETERR(xs, HBA_SELTIMEOUT);
4445                         return (CMD_COMPLETE);
4446                 }
4447         } else {
4448                 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4449                 if (isp->isp_state != ISP_RUNSTATE) {
4450                         isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4451                         XS_SETERR(xs, HBA_BOTCH);
4452                         return (CMD_COMPLETE);
4453                 }
4454
4455                 if (sdp->update) {
4456                         isp_spi_update(isp, XS_CHANNEL(xs));
4457                 }
4458                 lp = NULL;
4459         }
4460
4461  start_again:
4462
4463         qep = isp_getrqentry(isp);
4464         if (qep == NULL) {
4465                 isp_prt(isp, ISP_LOG_WARN1, "Request Queue Overflow");
4466                 XS_SETERR(xs, HBA_BOTCH);
4467                 return (CMD_EAGAIN);
4468         }
4469         XS_SETERR(xs, HBA_NOERROR);
4470
4471         /*
4472          * Now see if we need to synchronize the ISP with respect to anything.
4473          * We do dual duty here (cough) for synchronizing for buses other
4474          * than which we got here to send a command to.
4475          */
4476         reqp = (ispreq_t *) local;
4477         ISP_MEMZERO(local, QENTRY_LEN);
4478         if (ISP_TST_SENDMARKER(isp, XS_CHANNEL(xs))) {
4479                 if (IS_24XX(isp)) {
4480                         isp_marker_24xx_t *m = (isp_marker_24xx_t *) reqp;
4481                         m->mrk_header.rqs_entry_count = 1;
4482                         m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4483                         m->mrk_modifier = SYNC_ALL;
4484                         m->mrk_vphdl = XS_CHANNEL(xs);
4485                         isp_put_marker_24xx(isp, m, qep);
4486                 } else {
4487                         isp_marker_t *m = (isp_marker_t *) reqp;
4488                         m->mrk_header.rqs_entry_count = 1;
4489                         m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4490                         m->mrk_target = (XS_CHANNEL(xs) << 7);  /* bus # */
4491                         m->mrk_modifier = SYNC_ALL;
4492                         isp_put_marker(isp, m, qep);
4493                 }
4494                 ISP_SYNC_REQUEST(isp);
4495                 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 0);
4496                 goto start_again;
4497         }
4498
4499         reqp->req_header.rqs_entry_count = 1;
4500
4501         /*
4502          * Select and install Header Code.
4503          * Note that it might be overridden before going out
4504          * if we're on a 64 bit platform. The lower level
4505          * code (isp_send_cmd) will select the appropriate
4506          * 64 bit variant if it needs to.
4507          */
4508         if (IS_24XX(isp)) {
4509                 reqp->req_header.rqs_entry_type = RQSTYPE_T7RQS;
4510         } else if (IS_FC(isp)) {
4511                 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
4512         } else {
4513                 if (XS_CDBLEN(xs) > 12) {
4514                         reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
4515                 } else {
4516                         reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
4517                 }
4518         }
4519
4520         /*
4521          * Set task attributes
4522          */
4523         if (IS_24XX(isp)) {
4524                 int ttype;
4525                 if (XS_TAG_P(xs)) {
4526                         ttype = XS_TAG_TYPE(xs);
4527                 } else {
4528                         ttype = REQFLAG_STAG;
4529                 }
4530                 if (ttype == REQFLAG_OTAG) {
4531                         ttype = FCP_CMND_TASK_ATTR_ORDERED;
4532                 } else if (ttype == REQFLAG_HTAG) {
4533                         ttype = FCP_CMND_TASK_ATTR_HEAD;
4534                 } else {
4535                         ttype = FCP_CMND_TASK_ATTR_SIMPLE;
4536                 }
4537                 ((ispreqt7_t *)reqp)->req_task_attribute = ttype;
4538         } else if (IS_FC(isp)) {
4539                 /*
4540                  * See comment in isp_intr_respq
4541                  */
4542                 /* XS_SET_RESID(xs, 0); */
4543
4544                 /*
4545                  * Fibre Channel always requires some kind of tag.
4546                  * The Qlogic drivers seem be happy not to use a tag,
4547                  * but this breaks for some devices (IBM drives).
4548                  */
4549                 if (XS_TAG_P(xs)) {
4550                         ((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs);
4551                 } else {
4552                         ((ispreqt2_t *)reqp)->req_flags = REQFLAG_STAG;
4553                 }
4554         } else {
4555                 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4556                 if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) && XS_TAG_P(xs)) {
4557                         reqp->req_flags = XS_TAG_TYPE(xs);
4558                 }
4559         }
4560
4561         /*
4562          * NB: we do not support long CDBs (yet)
4563          */
4564         cdblen = XS_CDBLEN(xs);
4565
4566         if (IS_SCSI(isp)) {
4567                 if (cdblen > sizeof (reqp->req_cdb)) {
4568                         isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4569                         XS_SETERR(xs, HBA_REQINVAL);
4570                         return (CMD_COMPLETE);
4571                 }
4572                 reqp->req_target = target | (XS_CHANNEL(xs) << 7);
4573                 reqp->req_lun_trn = XS_LUN(xs);
4574                 reqp->req_cdblen = cdblen;
4575                 tptr = &reqp->req_time;
4576                 cdbp = reqp->req_cdb;
4577         } else if (IS_24XX(isp)) {
4578                 ispreqt7_t *t7 = (ispreqt7_t *)local;
4579
4580                 if (cdblen > sizeof (t7->req_cdb)) {
4581                         isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4582                         XS_SETERR(xs, HBA_REQINVAL);
4583                         return (CMD_COMPLETE);
4584                 }
4585
4586                 t7->req_nphdl = lp->handle;
4587                 t7->req_tidlo = lp->portid;
4588                 t7->req_tidhi = lp->portid >> 16;
4589                 t7->req_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(xs));
4590                 be64enc(t7->req_lun, CAM_EXTLUN_BYTE_SWIZZLE(XS_LUN(xs)));
4591                 if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
4592                         if (FCP_NEXT_CRN(isp, &t7->req_crn, xs)) {
4593                                 isp_prt(isp, ISP_LOG_WARN1,
4594                                     "%d.%d.%jx cannot generate next CRN",
4595                                     XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4596                                 XS_SETERR(xs, HBA_BOTCH);
4597                                 return (CMD_EAGAIN);
4598                         }
4599                 }
4600                 tptr = &t7->req_time;
4601                 cdbp = t7->req_cdb;
4602         } else {
4603                 ispreqt2_t *t2 = (ispreqt2_t *)local;
4604
4605                 if (cdblen > sizeof t2->req_cdb) {
4606                         isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4607                         XS_SETERR(xs, HBA_REQINVAL);
4608                         return (CMD_COMPLETE);
4609                 }
4610                 if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
4611                         if (FCP_NEXT_CRN(isp, &t2->req_crn, xs)) {
4612                                 isp_prt(isp, ISP_LOG_WARN1,
4613                                     "%d.%d.%jx cannot generate next CRN",
4614                                     XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4615                                 XS_SETERR(xs, HBA_BOTCH);
4616                                 return (CMD_EAGAIN);
4617                         }
4618                 }
4619                 if (ISP_CAP_2KLOGIN(isp)) {
4620                         ispreqt2e_t *t2e = (ispreqt2e_t *)local;
4621                         t2e->req_target = lp->handle;
4622                         t2e->req_scclun = XS_LUN(xs);
4623                         tptr = &t2e->req_time;
4624                         cdbp = t2e->req_cdb;
4625                 } else if (ISP_CAP_SCCFW(isp)) {
4626                         t2->req_target = lp->handle;
4627                         t2->req_scclun = XS_LUN(xs);
4628                         tptr = &t2->req_time;
4629                         cdbp = t2->req_cdb;
4630                 } else {
4631                         t2->req_target = lp->handle;
4632                         t2->req_lun_trn = XS_LUN(xs);
4633                         tptr = &t2->req_time;
4634                         cdbp = t2->req_cdb;
4635                 }
4636         }
4637         *tptr = XS_TIME(xs);
4638         ISP_MEMCPY(cdbp, XS_CDBP(xs), cdblen);
4639
4640         /* Whew. Thankfully the same for type 7 requests */
4641         reqp->req_handle = isp_allocate_handle(isp, xs, ISP_HANDLE_INITIATOR);
4642         if (reqp->req_handle == 0) {
4643                 isp_prt(isp, ISP_LOG_WARN1, "out of xflist pointers");
4644                 XS_SETERR(xs, HBA_BOTCH);
4645                 return (CMD_EAGAIN);
4646         }
4647
4648         /*
4649          * Set up DMA and/or do any platform dependent swizzling of the request entry
4650          * so that the Qlogic F/W understands what is being asked of it.
4651          *
4652          * The callee is responsible for adding all requests at this point.
4653          */
4654         dmaresult = ISP_DMASETUP(isp, xs, reqp);
4655         if (dmaresult != CMD_QUEUED) {
4656                 isp_destroy_handle(isp, reqp->req_handle);
4657                 /*
4658                  * dmasetup sets actual error in packet, and
4659                  * return what we were given to return.
4660                  */
4661                 return (dmaresult);
4662         }
4663         isp_xs_prt(isp, xs, ISP_LOGDEBUG0, "START cmd cdb[0]=0x%x datalen %ld", XS_CDBP(xs)[0], (long) XS_XFRLEN(xs));
4664         return (CMD_QUEUED);
4665 }
4666
4667 /*
4668  * isp control
4669  * Locks (ints blocked) assumed held.
4670  */
4671
4672 int
4673 isp_control(ispsoftc_t *isp, ispctl_t ctl, ...)
4674 {
4675         XS_T *xs;
4676         mbreg_t *mbr, mbs;
4677         int chan, tgt;
4678         uint32_t handle;
4679         va_list ap;
4680
4681         switch (ctl) {
4682         case ISPCTL_RESET_BUS:
4683                 /*
4684                  * Issue a bus reset.
4685                  */
4686                 if (IS_24XX(isp)) {
4687                         isp_prt(isp, ISP_LOGERR, "BUS RESET NOT IMPLEMENTED");
4688                         break;
4689                 } else if (IS_FC(isp)) {
4690                         mbs.param[1] = 10;
4691                         chan = 0;
4692                 } else {
4693                         va_start(ap, ctl);
4694                         chan = va_arg(ap, int);
4695                         va_end(ap);
4696                         mbs.param[1] = SDPARAM(isp, chan)->isp_bus_reset_delay;
4697                         if (mbs.param[1] < 2) {
4698                                 mbs.param[1] = 2;
4699                         }
4700                         mbs.param[2] = chan;
4701                 }
4702                 MBSINIT(&mbs, MBOX_BUS_RESET, MBLOGALL, 0);
4703                 ISP_SET_SENDMARKER(isp, chan, 1);
4704                 isp_mboxcmd(isp, &mbs);
4705                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4706                         break;
4707                 }
4708                 isp_prt(isp, ISP_LOGINFO, "driver initiated bus reset of bus %d", chan);
4709                 return (0);
4710
4711         case ISPCTL_RESET_DEV:
4712                 va_start(ap, ctl);
4713                 chan = va_arg(ap, int);
4714                 tgt = va_arg(ap, int);
4715                 va_end(ap);
4716                 if (IS_24XX(isp)) {
4717                         uint8_t local[QENTRY_LEN];
4718                         isp24xx_tmf_t *tmf;
4719                         isp24xx_statusreq_t *sp;
4720                         fcparam *fcp = FCPARAM(isp, chan);
4721                         fcportdb_t *lp;
4722
4723                         if (tgt < 0 || tgt >= MAX_FC_TARG) {
4724                                 isp_prt(isp, ISP_LOGWARN, "Chan %d trying to reset bad target %d", chan, tgt);
4725                                 break;
4726                         }
4727                         lp = &fcp->portdb[tgt];
4728                         if (lp->is_target == 0 ||
4729                             lp->state != FC_PORTDB_STATE_VALID) {
4730                                 isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
4731                                 break;
4732                         }
4733
4734                         tmf = (isp24xx_tmf_t *) local;
4735                         ISP_MEMZERO(tmf, QENTRY_LEN);
4736                         tmf->tmf_header.rqs_entry_type = RQSTYPE_TSK_MGMT;
4737                         tmf->tmf_header.rqs_entry_count = 1;
4738                         tmf->tmf_nphdl = lp->handle;
4739                         tmf->tmf_delay = 2;
4740                         tmf->tmf_timeout = 4;
4741                         tmf->tmf_flags = ISP24XX_TMF_TARGET_RESET;
4742                         tmf->tmf_tidlo = lp->portid;
4743                         tmf->tmf_tidhi = lp->portid >> 16;
4744                         tmf->tmf_vpidx = ISP_GET_VPIDX(isp, chan);
4745                         isp_put_24xx_tmf(isp, tmf, isp->isp_iocb);
4746                         if (isp->isp_dblev & ISP_LOGDEBUG1)
4747                                 isp_print_bytes(isp, "TMF IOCB request", QENTRY_LEN, isp->isp_iocb);
4748                         MEMORYBARRIER(isp, SYNC_IFORDEV, 0, QENTRY_LEN, chan);
4749                         fcp->sendmarker = 1;
4750
4751                         isp_prt(isp, ISP_LOGALL, "Chan %d Reset N-Port Handle 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
4752                         MBSINIT(&mbs, MBOX_EXEC_COMMAND_IOCB_A64, MBLOGALL,
4753                             MBCMD_DEFAULT_TIMEOUT + tmf->tmf_timeout * 1000000);
4754                         mbs.param[1] = QENTRY_LEN;
4755                         mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
4756                         mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
4757                         mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
4758                         mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
4759                         isp_mboxcmd(isp, &mbs);
4760                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
4761                                 break;
4762
4763                         MEMORYBARRIER(isp, SYNC_IFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
4764                         if (isp->isp_dblev & ISP_LOGDEBUG1)
4765                                 isp_print_bytes(isp, "TMF IOCB response", QENTRY_LEN, &((isp24xx_statusreq_t *)isp->isp_iocb)[1]);
4766                         sp = (isp24xx_statusreq_t *) local;
4767                         isp_get_24xx_response(isp, &((isp24xx_statusreq_t *)isp->isp_iocb)[1], sp);
4768                         if (sp->req_completion_status == 0) {
4769                                 return (0);
4770                         }
4771                         isp_prt(isp, ISP_LOGWARN, "Chan %d reset of target %d returned 0x%x", chan, tgt, sp->req_completion_status);
4772                         break;
4773                 } else if (IS_FC(isp)) {
4774                         if (ISP_CAP_2KLOGIN(isp)) {
4775                                 mbs.param[1] = tgt;
4776                                 mbs.ibits = (1 << 10);
4777                         } else {
4778                                 mbs.param[1] = (tgt << 8);
4779                         }
4780                 } else {
4781                         mbs.param[1] = (chan << 15) | (tgt << 8);
4782                 }
4783                 MBSINIT(&mbs, MBOX_ABORT_TARGET, MBLOGALL, 0);
4784                 mbs.param[2] = 3;       /* 'delay', in seconds */
4785                 isp_mboxcmd(isp, &mbs);
4786                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4787                         break;
4788                 }
4789                 isp_prt(isp, ISP_LOGINFO, "Target %d on Bus %d Reset Succeeded", tgt, chan);
4790                 ISP_SET_SENDMARKER(isp, chan, 1);
4791                 return (0);
4792
4793         case ISPCTL_ABORT_CMD:
4794                 va_start(ap, ctl);
4795                 xs = va_arg(ap, XS_T *);
4796                 va_end(ap);
4797
4798                 tgt = XS_TGT(xs);
4799                 chan = XS_CHANNEL(xs);
4800
4801                 handle = isp_find_handle(isp, xs);
4802                 if (handle == 0) {
4803                         isp_prt(isp, ISP_LOGWARN, "cannot find handle for command to abort");
4804                         break;
4805                 }
4806                 if (IS_24XX(isp)) {
4807                         isp24xx_abrt_t local, *ab = &local;
4808                         fcparam *fcp;
4809                         fcportdb_t *lp;
4810
4811                         fcp = FCPARAM(isp, chan);
4812                         if (tgt < 0 || tgt >= MAX_FC_TARG) {
4813                                 isp_prt(isp, ISP_LOGWARN, "Chan %d trying to abort bad target %d", chan, tgt);
4814                                 break;
4815                         }
4816                         lp = &fcp->portdb[tgt];
4817                         if (lp->is_target == 0 ||
4818                             lp->state != FC_PORTDB_STATE_VALID) {
4819                                 isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
4820                                 break;
4821                         }
4822                         isp_prt(isp, ISP_LOGALL, "Chan %d Abort Cmd for N-Port 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
4823                         ISP_MEMZERO(ab, QENTRY_LEN);
4824                         ab->abrt_header.rqs_entry_type = RQSTYPE_ABORT_IO;
4825                         ab->abrt_header.rqs_entry_count = 1;
4826                         ab->abrt_handle = lp->handle;
4827                         ab->abrt_cmd_handle = handle;
4828                         ab->abrt_tidlo = lp->portid;
4829                         ab->abrt_tidhi = lp->portid >> 16;
4830                         ab->abrt_vpidx = ISP_GET_VPIDX(isp, chan);
4831                         isp_put_24xx_abrt(isp, ab, isp->isp_iocb);
4832                         if (isp->isp_dblev & ISP_LOGDEBUG1)
4833                                 isp_print_bytes(isp, "AB IOCB quest", QENTRY_LEN, isp->isp_iocb);
4834                         MEMORYBARRIER(isp, SYNC_IFORDEV, 0, 2 * QENTRY_LEN, chan);
4835
4836                         ISP_MEMZERO(&mbs, sizeof (mbs));
4837                         MBSINIT(&mbs, MBOX_EXEC_COMMAND_IOCB_A64, MBLOGALL, 5000000);
4838                         mbs.param[1] = QENTRY_LEN;
4839                         mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
4840                         mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
4841                         mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
4842                         mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
4843
4844                         isp_mboxcmd(isp, &mbs);
4845                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
4846                                 break;
4847
4848                         MEMORYBARRIER(isp, SYNC_IFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
4849                         if (isp->isp_dblev & ISP_LOGDEBUG1)
4850                                 isp_print_bytes(isp, "AB IOCB response", QENTRY_LEN, &((isp24xx_abrt_t *)isp->isp_iocb)[1]);
4851                         isp_get_24xx_abrt(isp, &((isp24xx_abrt_t *)isp->isp_iocb)[1], ab);
4852                         if (ab->abrt_nphdl == ISP24XX_ABRT_OKAY) {
4853                                 return (0);
4854                         }
4855                         isp_prt(isp, ISP_LOGWARN, "Chan %d handle %d abort returned 0x%x", chan, tgt, ab->abrt_nphdl);
4856                         break;
4857                 } else if (IS_FC(isp)) {
4858                         if (ISP_CAP_SCCFW(isp)) {
4859                                 if (ISP_CAP_2KLOGIN(isp)) {
4860                                         mbs.param[1] = tgt;
4861                                 } else {
4862                                         mbs.param[1] = tgt << 8;
4863                                 }
4864                                 mbs.param[6] = XS_LUN(xs);
4865                         } else {
4866                                 mbs.param[1] = tgt << 8 | XS_LUN(xs);
4867                         }
4868                 } else {
4869                         mbs.param[1] = (chan << 15) | (tgt << 8) | XS_LUN(xs);
4870                 }
4871                 MBSINIT(&mbs, MBOX_ABORT,
4872                     MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_ERROR), 0);
4873                 mbs.param[2] = handle;
4874                 isp_mboxcmd(isp, &mbs);
4875                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4876                         break;
4877                 }
4878                 return (0);
4879
4880         case ISPCTL_UPDATE_PARAMS:
4881
4882                 va_start(ap, ctl);
4883                 chan = va_arg(ap, int);
4884                 va_end(ap);
4885                 isp_spi_update(isp, chan);
4886                 return (0);
4887
4888         case ISPCTL_FCLINK_TEST:
4889
4890                 if (IS_FC(isp)) {
4891                         int usdelay;
4892                         va_start(ap, ctl);
4893                         chan = va_arg(ap, int);
4894                         usdelay = va_arg(ap, int);
4895                         va_end(ap);
4896                         if (usdelay == 0) {
4897                                 usdelay =  250000;
4898                         }
4899                         return (isp_fclink_test(isp, chan, usdelay));
4900                 }
4901                 break;
4902
4903         case ISPCTL_SCAN_FABRIC:
4904
4905                 if (IS_FC(isp)) {
4906                         va_start(ap, ctl);
4907                         chan = va_arg(ap, int);
4908                         va_end(ap);
4909                         return (isp_scan_fabric(isp, chan));
4910                 }
4911                 break;
4912
4913         case ISPCTL_SCAN_LOOP:
4914
4915                 if (IS_FC(isp)) {
4916                         va_start(ap, ctl);
4917                         chan = va_arg(ap, int);
4918                         va_end(ap);
4919                         return (isp_scan_loop(isp, chan));
4920                 }
4921                 break;
4922
4923         case ISPCTL_PDB_SYNC:
4924
4925                 if (IS_FC(isp)) {
4926                         va_start(ap, ctl);
4927                         chan = va_arg(ap, int);
4928                         va_end(ap);
4929                         return (isp_pdb_sync(isp, chan));
4930                 }
4931                 break;
4932
4933         case ISPCTL_SEND_LIP:
4934
4935                 if (IS_FC(isp) && !IS_24XX(isp)) {
4936                         MBSINIT(&mbs, MBOX_INIT_LIP, MBLOGALL, 0);
4937                         if (ISP_CAP_2KLOGIN(isp)) {
4938                                 mbs.ibits = (1 << 10);
4939                         }
4940                         isp_mboxcmd(isp, &mbs);
4941                         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
4942                                 return (0);
4943                         }
4944                 }
4945                 break;
4946
4947         case ISPCTL_GET_PDB:
4948                 if (IS_FC(isp)) {
4949                         isp_pdb_t *pdb;
4950                         va_start(ap, ctl);
4951                         chan = va_arg(ap, int);
4952                         tgt = va_arg(ap, int);
4953                         pdb = va_arg(ap, isp_pdb_t *);
4954                         va_end(ap);
4955                         return (isp_getpdb(isp, chan, tgt, pdb));
4956                 }
4957                 break;
4958
4959         case ISPCTL_GET_NAMES:
4960         {
4961                 uint64_t *wwnn, *wwnp;
4962                 va_start(ap, ctl);
4963                 chan = va_arg(ap, int);
4964                 tgt = va_arg(ap, int);
4965                 wwnn = va_arg(ap, uint64_t *);
4966                 wwnp = va_arg(ap, uint64_t *);
4967                 va_end(ap);
4968                 if (wwnn == NULL && wwnp == NULL) {
4969                         break;
4970                 }
4971                 if (wwnn) {
4972                         *wwnn = isp_get_wwn(isp, chan, tgt, 1);
4973                         if (*wwnn == INI_NONE) {
4974                                 break;
4975                         }
4976                 }
4977                 if (wwnp) {
4978                         *wwnp = isp_get_wwn(isp, chan, tgt, 0);
4979                         if (*wwnp == INI_NONE) {
4980                                 break;
4981                         }
4982                 }
4983                 return (0);
4984         }
4985         case ISPCTL_RUN_MBOXCMD:
4986         {
4987                 va_start(ap, ctl);
4988                 mbr = va_arg(ap, mbreg_t *);
4989                 va_end(ap);
4990                 isp_mboxcmd(isp, mbr);
4991                 return (0);
4992         }
4993         case ISPCTL_PLOGX:
4994         {
4995                 isp_plcmd_t *p;
4996                 int r;
4997
4998                 va_start(ap, ctl);
4999                 p = va_arg(ap, isp_plcmd_t *);
5000                 va_end(ap);
5001
5002                 if ((p->flags & PLOGX_FLG_CMD_MASK) != PLOGX_FLG_CMD_PLOGI || (p->handle != NIL_HANDLE)) {
5003                         return (isp_plogx(isp, p->channel, p->handle, p->portid, p->flags));
5004                 }
5005                 do {
5006                         isp_next_handle(isp, &p->handle);
5007                         r = isp_plogx(isp, p->channel, p->handle, p->portid, p->flags);
5008                         if ((r & 0xffff) == MBOX_PORT_ID_USED) {
5009                                 p->handle = r >> 16;
5010                                 r = 0;
5011                                 break;
5012                         }
5013                 } while ((r & 0xffff) == MBOX_LOOP_ID_USED);
5014                 return (r);
5015         }
5016         case ISPCTL_CHANGE_ROLE:
5017                 if (IS_FC(isp)) {
5018                         int role, r;
5019
5020                         va_start(ap, ctl);
5021                         chan = va_arg(ap, int);
5022                         role = va_arg(ap, int);
5023                         va_end(ap);
5024                         r = isp_fc_change_role(isp, chan, role);
5025                         return (r);
5026                 }
5027                 break;
5028         default:
5029                 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
5030                 break;
5031
5032         }
5033         return (-1);
5034 }
5035
5036 /*
5037  * Interrupt Service Routine(s).
5038  *
5039  * External (OS) framework has done the appropriate locking,
5040  * and the locking will be held throughout this function.
5041  */
5042
5043 #ifdef  ISP_TARGET_MODE
5044 void
5045 isp_intr_atioq(ispsoftc_t *isp)
5046 {
5047         uint8_t qe[QENTRY_LEN];
5048         isphdr_t *hp;
5049         void *addr;
5050         uint32_t iptr, optr, oop;
5051
5052         iptr = ISP_READ(isp, BIU2400_ATIO_RSPINP);
5053         optr = isp->isp_atioodx;
5054         while (optr != iptr) {
5055                 oop = optr;
5056                 MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN, -1);
5057                 addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
5058                 isp_get_hdr(isp, addr, (isphdr_t *)qe);
5059                 hp = (isphdr_t *)qe;
5060                 switch (hp->rqs_entry_type) {
5061                 case RQSTYPE_NOTIFY:
5062                 case RQSTYPE_ATIO:
5063                         (void) isp_target_notify(isp, addr, &oop);
5064                         break;
5065                 default:
5066                         isp_print_qentry(isp, "?ATIOQ entry?", oop, addr);
5067                         break;
5068                 }
5069                 optr = ISP_NXT_QENTRY(oop, RESULT_QUEUE_LEN(isp));
5070         }
5071         if (isp->isp_atioodx != optr) {
5072                 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, optr);
5073                 isp->isp_atioodx = optr;
5074         }
5075 }
5076 #endif
5077
5078 void
5079 isp_intr_async(ispsoftc_t *isp, uint16_t event)
5080 {
5081
5082         if (IS_FC(isp))
5083                 isp_parse_async_fc(isp, event);
5084         else
5085                 isp_parse_async(isp, event);
5086 }
5087
5088 void
5089 isp_intr_mbox(ispsoftc_t *isp, uint16_t mbox0)
5090 {
5091         int i, obits;
5092
5093         if (!isp->isp_mboxbsy) {
5094                 isp_prt(isp, ISP_LOGWARN, "mailbox 0x%x with no waiters", mbox0);
5095                 return;
5096         }
5097         obits = isp->isp_obits;
5098         isp->isp_mboxtmp[0] = mbox0;
5099         for (i = 1; i < ISP_NMBOX(isp); i++) {
5100                 if ((obits & (1 << i)) == 0)
5101                         continue;
5102                 isp->isp_mboxtmp[i] = ISP_READ(isp, MBOX_OFF(i));
5103         }
5104         MBOX_NOTIFY_COMPLETE(isp);
5105 }
5106
5107 void
5108 isp_intr_respq(ispsoftc_t *isp)
5109 {
5110         XS_T *xs, *cont_xs;
5111         uint8_t qe[QENTRY_LEN];
5112         ispstatusreq_t *sp = (ispstatusreq_t *)qe;
5113         isp24xx_statusreq_t *sp2 = (isp24xx_statusreq_t *)qe;
5114         isphdr_t *hp;
5115         uint8_t *resp, *snsp;
5116         int buddaboom, completion_status, cont = 0, etype, i;
5117         int req_status_flags, req_state_flags, scsi_status;
5118         uint32_t iptr, junk, cptr, optr, rlen, slen, sptr, totslen, resid;
5119
5120         /*
5121          * We can't be getting this now.
5122          */
5123         if (isp->isp_state != ISP_RUNSTATE) {
5124                 isp_prt(isp, ISP_LOGINFO, "respq interrupt when not ready");
5125                 return;
5126         }
5127
5128         iptr = ISP_READ(isp, isp->isp_respinrp);
5129         /* Debounce the 2300 if revision less than 2. */
5130         if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
5131                 do {
5132                         junk = iptr;
5133                         iptr = ISP_READ(isp, isp->isp_respinrp);
5134                 } while (junk != iptr);
5135         }
5136         isp->isp_residx = iptr;
5137
5138         optr = isp->isp_resodx;
5139         while (optr != iptr) {
5140                 sptr = cptr = optr;
5141                 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, cptr);
5142                 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
5143
5144                 /*
5145                  * Synchronize our view of this response queue entry.
5146                  */
5147                 MEMORYBARRIER(isp, SYNC_RESULT, cptr, QENTRY_LEN, -1);
5148                 if (isp->isp_dblev & ISP_LOGDEBUG1)
5149                         isp_print_qentry(isp, "Response Queue Entry", cptr, hp);
5150                 isp_get_hdr(isp, hp, &sp->req_header);
5151                 etype = sp->req_header.rqs_entry_type;
5152
5153                 /* We expected Status Continuation, but got different IOCB. */
5154                 if (cont > 0 && etype != RQSTYPE_STATUS_CONT) {
5155                         cont = 0;
5156                         isp_done(cont_xs);
5157                 }
5158
5159                 if (IS_24XX(isp) && etype == RQSTYPE_RESPONSE) {
5160                         isp_get_24xx_response(isp, (isp24xx_statusreq_t *)hp, sp2);
5161                         scsi_status = sp2->req_scsi_status;
5162                         completion_status = sp2->req_completion_status;
5163                         req_status_flags = 0;
5164                         if ((scsi_status & 0xff) != 0)
5165                                 req_state_flags = RQSF_GOT_STATUS;
5166                         else
5167                                 req_state_flags = 0;
5168                         resid = sp2->req_resid;
5169                 } else if (etype == RQSTYPE_RESPONSE) {
5170                         isp_get_response(isp, (ispstatusreq_t *) hp, sp);
5171                         scsi_status = sp->req_scsi_status;
5172                         completion_status = sp->req_completion_status;
5173                         req_status_flags = sp->req_status_flags;
5174                         req_state_flags = sp->req_state_flags;
5175                         resid = sp->req_resid;
5176                 } else if (etype == RQSTYPE_RIO1) {
5177                         isp_rio1_t *rio = (isp_rio1_t *) qe;
5178                         isp_get_rio1(isp, (isp_rio1_t *) hp, rio);
5179                         for (i = 0; i < rio->req_header.rqs_seqno; i++) {
5180                                 isp_fastpost_complete(isp, rio->req_handles[i]);
5181                         }
5182                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
5183                         continue;
5184                 } else if (etype == RQSTYPE_RIO2) {
5185                         isp_prt(isp, ISP_LOGERR, "dropping RIO2 response");
5186                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
5187                         continue;
5188                 } else if (etype == RQSTYPE_STATUS_CONT) {
5189                         ispstatus_cont_t *scp = (ispstatus_cont_t *)qe;
5190                         isp_get_cont_response(isp, (ispstatus_cont_t *)hp, scp);
5191                         if (cont > 0) {
5192                                 i = min(cont, sizeof(scp->req_sense_data));
5193                                 XS_SENSE_APPEND(cont_xs, scp->req_sense_data, i);
5194                                 cont -= i;
5195                                 if (cont == 0) {
5196                                         isp_done(cont_xs);
5197                                 } else {
5198                                         isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
5199                                             "Expecting Status Continuations for %u bytes",
5200                                             cont);
5201                                 }
5202                         } else {
5203                                 isp_prt(isp, ISP_LOG_WARN1, "Ignored Continuation Response");
5204                         }
5205                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
5206                         continue;
5207                 } else if (isp_handle_other_response(isp, etype, hp, &cptr)) {
5208                         /* More then one IOCB could be consumed. */
5209                         while (sptr != cptr) {
5210                                 ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
5211                                 sptr = ISP_NXT_QENTRY(sptr, RESULT_QUEUE_LEN(isp));
5212                                 hp = (isphdr_t *)ISP_QUEUE_ENTRY(isp->isp_result, sptr);
5213                         }
5214                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
5215                         optr = ISP_NXT_QENTRY(cptr, RESULT_QUEUE_LEN(isp));
5216                         continue;
5217                 } else {
5218                         /* We don't know what was this -- log and skip. */
5219                         isp_prt(isp, ISP_LOGERR, notresp, etype, cptr, optr);
5220                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
5221                         continue;
5222                 }
5223
5224                 buddaboom = 0;
5225                 if (sp->req_header.rqs_flags & RQSFLAG_MASK) {
5226                         if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
5227                                 isp_print_qentry(isp, "unexpected continuation segment",
5228                                     cptr, hp);
5229                                 continue;
5230                         }
5231                         if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
5232                                 isp_prt(isp, ISP_LOG_WARN1, "internal queues full");
5233                                 /*
5234                                  * We'll synthesize a QUEUE FULL message below.
5235                                  */
5236                         }
5237                         if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
5238                                 isp_print_qentry(isp, "bad header flag",
5239                                     cptr, hp);
5240                                 buddaboom++;
5241                         }
5242                         if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
5243                                 isp_print_qentry(isp, "bad request packet",
5244                                     cptr, hp);
5245                                 buddaboom++;
5246                         }
5247                         if (sp->req_header.rqs_flags & RQSFLAG_BADCOUNT) {
5248                                 isp_print_qentry(isp, "invalid entry count",
5249                                     cptr, hp);
5250                                 buddaboom++;
5251                         }
5252                         if (sp->req_header.rqs_flags & RQSFLAG_BADORDER) {
5253                                 isp_print_qentry(isp, "invalid IOCB ordering",
5254                                     cptr, hp);
5255                                 continue;
5256                         }
5257                 }
5258
5259                 xs = isp_find_xs(isp, sp->req_handle);
5260                 if (xs == NULL) {
5261                         uint8_t ts = completion_status & 0xff;
5262                         /*
5263                          * Only whine if this isn't the expected fallout of
5264                          * aborting the command or resetting the target.
5265                          */
5266                         if (etype != RQSTYPE_RESPONSE) {
5267                                 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (type 0x%x)", sp->req_handle, etype);
5268                         } else if (ts != RQCS_ABORTED && ts != RQCS_RESET_OCCURRED) {
5269                                 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (status 0x%x)", sp->req_handle, ts);
5270                         }
5271                         ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
5272                         continue;
5273                 }
5274                 if (req_status_flags & RQSTF_BUS_RESET) {
5275                         isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%jx bus was reset",
5276                             XS_CHANNEL(xs), XS_TGT(xs), (uintmax_t)XS_LUN(xs));
5277                         XS_SETERR(xs, HBA_BUSRESET);
5278                         ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
5279                 }
5280                 if (buddaboom) {
5281                         isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%jx buddaboom",
5282                             XS_CHANNEL(xs), XS_TGT(xs), (uintmax_t)XS_LUN(xs));
5283                         XS_SETERR(xs, HBA_BOTCH);
5284                 }
5285
5286                 resp = snsp = NULL;
5287                 rlen = slen = totslen = 0;
5288                 if (IS_24XX(isp) && (scsi_status & (RQCS_RV|RQCS_SV)) != 0) {
5289                         resp = sp2->req_rsp_sense;
5290                         rlen = sp2->req_response_len;
5291                 } else if (IS_FC(isp) && (scsi_status & RQCS_RV) != 0) {
5292                         resp = sp->req_response;
5293                         rlen = sp->req_response_len;
5294                 }
5295                 if (IS_FC(isp) && (scsi_status & RQCS_SV) != 0) {
5296                         /*
5297                          * Fibre Channel F/W doesn't say we got status
5298                          * if there's Sense Data instead. I guess they
5299                          * think it goes w/o saying.
5300                          */
5301                         req_state_flags |= RQSF_GOT_STATUS|RQSF_GOT_SENSE;
5302                         if (IS_24XX(isp)) {
5303                                 snsp = sp2->req_rsp_sense;
5304                                 snsp += rlen;
5305                                 totslen = sp2->req_sense_len;
5306                                 slen = sizeof(sp2->req_rsp_sense) - rlen;
5307                         } else {
5308                                 snsp = sp->req_sense_data;
5309                                 totslen = sp->req_sense_len;
5310                                 slen = sizeof(sp->req_sense_data);
5311                         }
5312                 } else if (IS_SCSI(isp) && (req_state_flags & RQSF_GOT_SENSE)) {
5313                         snsp = sp->req_sense_data;
5314                         totslen = sp->req_sense_len;
5315                         slen = sizeof (sp->req_sense_data);
5316                 }
5317                 if (slen > totslen)
5318                         slen = totslen;
5319                 if (req_state_flags & RQSF_GOT_STATUS)
5320                         *XS_STSP(xs) = scsi_status & 0xff;
5321
5322                 if (rlen >= 4 && resp[FCP_RSPNS_CODE_OFFSET] != 0) {
5323                         const char *ptr;
5324                         char lb[64];
5325                         const char *rnames[10] = {
5326                             "Task Management function complete",
5327                             "FCP_DATA length different than FCP_BURST_LEN",
5328                             "FCP_CMND fields invalid",
5329                             "FCP_DATA parameter mismatch with FCP_DATA_RO",
5330                             "Task Management function rejected",
5331                             "Task Management function failed",
5332                             NULL,
5333                             NULL,
5334                             "Task Management function succeeded",
5335                             "Task Management function incorrect logical unit number",
5336                         };
5337                         uint8_t code = resp[FCP_RSPNS_CODE_OFFSET];
5338                         if (code >= 10 || rnames[code] == NULL) {
5339                                 ISP_SNPRINTF(lb, sizeof(lb),
5340                                     "Unknown FCP Response Code 0x%x", code);
5341                                 ptr = lb;
5342                         } else {
5343                                 ptr = rnames[code];
5344                         }
5345                         isp_xs_prt(isp, xs, ISP_LOGWARN,
5346                             "FCP RESPONSE, LENGTH %u: %s CDB0=0x%02x",
5347                             rlen, ptr, XS_CDBP(xs)[0] & 0xff);
5348                         if (code != 0 && code != 8)
5349                                 XS_SETERR(xs, HBA_BOTCH);
5350                 }
5351                 if (IS_24XX(isp))
5352                         isp_parse_status_24xx(isp, sp2, xs, &resid);
5353                 else
5354                         isp_parse_status(isp, sp, xs, &resid);
5355                 if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
5356                     (*XS_STSP(xs) == SCSI_BUSY))
5357                         XS_SETERR(xs, HBA_TGTBSY);
5358                 if (IS_SCSI(isp)) {
5359                         XS_SET_RESID(xs, resid);
5360                         /*
5361                          * A new synchronous rate was negotiated for
5362                          * this target. Mark state such that we'll go
5363                          * look up that which has changed later.
5364                          */
5365                         if (req_status_flags & RQSTF_NEGOTIATION) {
5366                                 int t = XS_TGT(xs);
5367                                 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
5368                                 sdp->isp_devparam[t].dev_refresh = 1;
5369                                 sdp->update = 1;
5370                         }
5371                 } else {
5372                         if (req_status_flags & RQSF_XFER_COMPLETE) {
5373                                 XS_SET_RESID(xs, 0);
5374                         } else if (scsi_status & RQCS_RESID) {
5375                                 XS_SET_RESID(xs, resid);
5376                         } else {
5377                                 XS_SET_RESID(xs, 0);
5378                         }
5379                 }
5380                 if (slen > 0) {
5381                         XS_SAVE_SENSE(xs, snsp, slen);
5382                         if (totslen > slen) {
5383                                 cont = totslen - slen;
5384                                 cont_xs = xs;
5385                                 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
5386                                     "Expecting Status Continuations for %u bytes",
5387                                     cont);
5388                         }
5389                 }
5390                 isp_prt(isp, ISP_LOGDEBUG2, "asked for %lu got raw resid %lu settled for %lu",
5391                     (u_long)XS_XFRLEN(xs), (u_long)resid, (u_long)XS_GET_RESID(xs));
5392
5393                 if (XS_XFRLEN(xs))
5394                         ISP_DMAFREE(isp, xs, sp->req_handle);
5395                 isp_destroy_handle(isp, sp->req_handle);
5396
5397                 ISP_MEMZERO(hp, QENTRY_LEN);    /* PERF */
5398
5399                 /* Complete command if we expect no Status Continuations. */
5400                 if (cont == 0)
5401                         isp_done(xs);
5402         }
5403
5404         /* We haven't received all Status Continuations, but that is it. */
5405         if (cont > 0)
5406                 isp_done(cont_xs);
5407
5408         /* If we processed any IOCBs, let ISP know about it. */
5409         if (optr != isp->isp_resodx) {
5410                 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5411                 isp->isp_resodx = optr;
5412         }
5413 }
5414
5415 /*
5416  * Parse an ASYNC mailbox complete
5417  */
5418 static void
5419 isp_parse_async(ispsoftc_t *isp, uint16_t mbox)
5420 {
5421         uint32_t h1 = 0, h2 = 0;
5422         uint16_t chan = 0;
5423
5424         /*
5425          * Pick up the channel, but not if this is a ASYNC_RIO32_2,
5426          * where Mailboxes 6/7 have the second handle.
5427          */
5428         if (mbox != ASYNC_RIO32_2) {
5429                 if (IS_DUALBUS(isp)) {
5430                         chan = ISP_READ(isp, OUTMAILBOX6);
5431                 }
5432         }
5433         isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5434
5435         switch (mbox) {
5436         case ASYNC_BUS_RESET:
5437                 ISP_SET_SENDMARKER(isp, chan, 1);
5438 #ifdef  ISP_TARGET_MODE
5439                 isp_target_async(isp, chan, mbox);
5440 #endif
5441                 isp_async(isp, ISPASYNC_BUS_RESET, chan);
5442                 break;
5443         case ASYNC_SYSTEM_ERROR:
5444                 isp->isp_state = ISP_CRASHED;
5445                 /*
5446                  * Were we waiting for a mailbox command to complete?
5447                  * If so, it's dead, so wake up the waiter.
5448                  */
5449                 if (isp->isp_mboxbsy) {
5450                         isp->isp_obits = 1;
5451                         isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5452                         MBOX_NOTIFY_COMPLETE(isp);
5453                 }
5454                 /*
5455                  * It's up to the handler for isp_async to reinit stuff and
5456                  * restart the firmware
5457                  */
5458                 isp_async(isp, ISPASYNC_FW_CRASH);
5459                 break;
5460
5461         case ASYNC_RQS_XFER_ERR:
5462                 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5463                 break;
5464
5465         case ASYNC_RSP_XFER_ERR:
5466                 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5467                 break;
5468
5469         case ASYNC_QWAKEUP:
5470                 /*
5471                  * We've just been notified that the Queue has woken up.
5472                  * We don't need to be chatty about this- just unlatch things
5473                  * and move on.
5474                  */
5475                 mbox = ISP_READ(isp, isp->isp_rqstoutrp);
5476                 break;
5477
5478         case ASYNC_TIMEOUT_RESET:
5479                 isp_prt(isp, ISP_LOGWARN, "timeout initiated SCSI bus reset of chan %d", chan);
5480                 ISP_SET_SENDMARKER(isp, chan, 1);
5481 #ifdef  ISP_TARGET_MODE
5482                 isp_target_async(isp, chan, mbox);
5483 #endif
5484                 break;
5485
5486         case ASYNC_DEVICE_RESET:
5487                 isp_prt(isp, ISP_LOGINFO, "device reset on chan %d", chan);
5488                 ISP_SET_SENDMARKER(isp, chan, 1);
5489 #ifdef  ISP_TARGET_MODE
5490                 isp_target_async(isp, chan, mbox);
5491 #endif
5492                 break;
5493
5494         case ASYNC_EXTMSG_UNDERRUN:
5495                 isp_prt(isp, ISP_LOGWARN, "extended message underrun");
5496                 break;
5497
5498         case ASYNC_SCAM_INT:
5499                 isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
5500                 break;
5501
5502         case ASYNC_HUNG_SCSI:
5503                 isp_prt(isp, ISP_LOGERR, "stalled SCSI Bus after DATA Overrun");
5504                 /* XXX: Need to issue SCSI reset at this point */
5505                 break;
5506
5507         case ASYNC_KILLED_BUS:
5508                 isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
5509                 break;
5510
5511         case ASYNC_BUS_TRANSIT:
5512                 mbox = ISP_READ(isp, OUTMAILBOX2);
5513                 switch (mbox & SXP_PINS_MODE_MASK) {
5514                 case SXP_PINS_LVD_MODE:
5515                         isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
5516                         SDPARAM(isp, chan)->isp_diffmode = 0;
5517                         SDPARAM(isp, chan)->isp_ultramode = 0;
5518                         SDPARAM(isp, chan)->isp_lvdmode = 1;
5519                         break;
5520                 case SXP_PINS_HVD_MODE:
5521                         isp_prt(isp, ISP_LOGINFO,
5522                             "Transition to Differential mode");
5523                         SDPARAM(isp, chan)->isp_diffmode = 1;
5524                         SDPARAM(isp, chan)->isp_ultramode = 0;
5525                         SDPARAM(isp, chan)->isp_lvdmode = 0;
5526                         break;
5527                 case SXP_PINS_SE_MODE:
5528                         isp_prt(isp, ISP_LOGINFO,
5529                             "Transition to Single Ended mode");
5530                         SDPARAM(isp, chan)->isp_diffmode = 0;
5531                         SDPARAM(isp, chan)->isp_ultramode = 1;
5532                         SDPARAM(isp, chan)->isp_lvdmode = 0;
5533                         break;
5534                 default:
5535                         isp_prt(isp, ISP_LOGWARN,
5536                             "Transition to Unknown Mode 0x%x", mbox);
5537                         break;
5538                 }
5539                 /*
5540                  * XXX: Set up to renegotiate again!
5541                  */
5542                 /* Can only be for a 1080... */
5543                 ISP_SET_SENDMARKER(isp, chan, 1);
5544                 break;
5545
5546         case ASYNC_CMD_CMPLT:
5547         case ASYNC_RIO32_1:
5548                 if (!IS_ULTRA3(isp)) {
5549                         isp_prt(isp, ISP_LOGERR, "unexpected fast posting completion");
5550                         break;
5551                 }
5552                 /* FALLTHROUGH */
5553                 h1 = (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1);
5554                 break;
5555
5556         case ASYNC_RIO32_2:
5557                 h1 = (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1);
5558                 h2 = (ISP_READ(isp, OUTMAILBOX7) << 16) | ISP_READ(isp, OUTMAILBOX6);
5559                 break;
5560
5561         case ASYNC_RIO16_5:
5562         case ASYNC_RIO16_4:
5563         case ASYNC_RIO16_3:
5564         case ASYNC_RIO16_2:
5565         case ASYNC_RIO16_1:
5566                 isp_prt(isp, ISP_LOGERR, "unexpected 16 bit RIO handle");
5567                 break;
5568         default:
5569                 isp_prt(isp, ISP_LOGWARN, "%s: unhandled async code 0x%x", __func__, mbox);
5570                 break;
5571         }
5572
5573         if (h1 || h2) {
5574                 isp_prt(isp, ISP_LOGDEBUG3, "fast post/rio completion of 0x%08x", h1);
5575                 isp_fastpost_complete(isp, h1);
5576                 if (h2) {
5577                         isp_prt(isp, ISP_LOGDEBUG3, "fast post/rio completion of 0x%08x", h2);
5578                         isp_fastpost_complete(isp, h2);
5579                 }
5580         }
5581 }
5582
5583 static void
5584 isp_parse_async_fc(ispsoftc_t *isp, uint16_t mbox)
5585 {
5586         fcparam *fcp;
5587         uint16_t chan;
5588
5589         if (IS_DUALBUS(isp)) {
5590                 chan = ISP_READ(isp, OUTMAILBOX6);
5591         } else {
5592                 chan = 0;
5593         }
5594         isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5595
5596         switch (mbox) {
5597         case ASYNC_SYSTEM_ERROR:
5598                 isp->isp_state = ISP_CRASHED;
5599                 FCPARAM(isp, chan)->isp_loopstate = LOOP_NIL;
5600                 isp_change_fw_state(isp, chan, FW_CONFIG_WAIT);
5601                 /*
5602                  * Were we waiting for a mailbox command to complete?
5603                  * If so, it's dead, so wake up the waiter.
5604                  */
5605                 if (isp->isp_mboxbsy) {
5606                         isp->isp_obits = 1;
5607                         isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5608                         MBOX_NOTIFY_COMPLETE(isp);
5609                 }
5610                 /*
5611                  * It's up to the handler for isp_async to reinit stuff and
5612                  * restart the firmware
5613                  */
5614                 isp_async(isp, ISPASYNC_FW_CRASH);
5615                 break;
5616
5617         case ASYNC_RQS_XFER_ERR:
5618                 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5619                 break;
5620
5621         case ASYNC_RSP_XFER_ERR:
5622                 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5623                 break;
5624
5625         case ASYNC_QWAKEUP:
5626 #ifdef  ISP_TARGET_MODE
5627                 if (IS_24XX(isp)) {
5628                         isp_prt(isp, ISP_LOGERR, "ATIO Queue Transfer Error");
5629                         break;
5630                 }
5631 #endif
5632                 isp_prt(isp, ISP_LOGERR, "%s: unexpected ASYNC_QWAKEUP code", __func__);
5633                 break;
5634
5635         case ASYNC_CMD_CMPLT:
5636                 isp_fastpost_complete(isp, (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1));
5637                 break;
5638
5639         case ASYNC_RIOZIO_STALL:
5640                 isp_intr_respq(isp);
5641                 break;
5642
5643         case ASYNC_CTIO_DONE:
5644 #ifdef  ISP_TARGET_MODE
5645                 isp_target_async(isp, (ISP_READ(isp, OUTMAILBOX2) << 16) |
5646                     ISP_READ(isp, OUTMAILBOX1), mbox);
5647 #else
5648                 isp_prt(isp, ISP_LOGWARN, "unexpected ASYNC CTIO done");
5649 #endif
5650                 break;
5651         case ASYNC_LIP_ERROR:
5652         case ASYNC_LIP_NOS_OLS_RECV:
5653         case ASYNC_LIP_OCCURRED:
5654         case ASYNC_PTPMODE:
5655                 /*
5656                  * These are broadcast events that have to be sent across
5657                  * all active channels.
5658                  */
5659                 for (chan = 0; chan < isp->isp_nchan; chan++) {
5660                         fcp = FCPARAM(isp, chan);
5661                         int topo = fcp->isp_topo;
5662
5663                         if (fcp->role == ISP_ROLE_NONE)
5664                                 continue;
5665                         if (fcp->isp_loopstate > LOOP_HAVE_LINK)
5666                                 fcp->isp_loopstate = LOOP_HAVE_LINK;
5667                         ISP_SET_SENDMARKER(isp, chan, 1);
5668                         isp_async(isp, ISPASYNC_LIP, chan);
5669 #ifdef  ISP_TARGET_MODE
5670                         isp_target_async(isp, chan, mbox);
5671 #endif
5672                         /*
5673                          * We've had problems with data corruption occurring on
5674                          * commands that complete (with no apparent error) after
5675                          * we receive a LIP. This has been observed mostly on
5676                          * Local Loop topologies. To be safe, let's just mark
5677                          * all active initiator commands as dead.
5678                          */
5679                         if (topo == TOPO_NL_PORT || topo == TOPO_FL_PORT) {
5680                                 int i, j;
5681                                 for (i = j = 0; i < isp->isp_maxcmds; i++) {
5682                                         XS_T *xs;
5683                                         isp_hdl_t *hdp;
5684
5685                                         hdp = &isp->isp_xflist[i];
5686                                         if (ISP_H2HT(hdp->handle) != ISP_HANDLE_INITIATOR) {
5687                                                 continue;
5688                                         }
5689                                         xs = hdp->cmd;
5690                                         if (XS_CHANNEL(xs) != chan) {
5691                                                 continue;
5692                                         }
5693                                         j++;
5694                                         isp_prt(isp, ISP_LOG_WARN1,
5695                                             "%d.%d.%jx bus reset set at %s:%u",
5696                                             XS_CHANNEL(xs), XS_TGT(xs),
5697                                             (uintmax_t)XS_LUN(xs),
5698                                             __func__, __LINE__);
5699                                         XS_SETERR(xs, HBA_BUSRESET);
5700                                 }
5701                                 if (j) {
5702                                         isp_prt(isp, ISP_LOGERR, lipd, chan, j);
5703                                 }
5704                         }
5705                 }
5706                 break;
5707
5708         case ASYNC_LOOP_UP:
5709                 /*
5710                  * This is a broadcast event that has to be sent across
5711                  * all active channels.
5712                  */
5713                 for (chan = 0; chan < isp->isp_nchan; chan++) {
5714                         fcp = FCPARAM(isp, chan);
5715                         if (fcp->role == ISP_ROLE_NONE)
5716                                 continue;
5717                         fcp->isp_linkstate = 1;
5718                         if (fcp->isp_loopstate < LOOP_HAVE_LINK)
5719                                 fcp->isp_loopstate = LOOP_HAVE_LINK;
5720                         ISP_SET_SENDMARKER(isp, chan, 1);
5721                         isp_async(isp, ISPASYNC_LOOP_UP, chan);
5722 #ifdef  ISP_TARGET_MODE
5723                         isp_target_async(isp, chan, mbox);
5724 #endif
5725                 }
5726                 break;
5727
5728         case ASYNC_LOOP_DOWN:
5729                 /*
5730                  * This is a broadcast event that has to be sent across
5731                  * all active channels.
5732                  */
5733                 for (chan = 0; chan < isp->isp_nchan; chan++) {
5734                         fcp = FCPARAM(isp, chan);
5735                         if (fcp->role == ISP_ROLE_NONE)
5736                                 continue;
5737                         ISP_SET_SENDMARKER(isp, chan, 1);
5738                         fcp->isp_linkstate = 0;
5739                         fcp->isp_loopstate = LOOP_NIL;
5740                         isp_async(isp, ISPASYNC_LOOP_DOWN, chan);
5741 #ifdef  ISP_TARGET_MODE
5742                         isp_target_async(isp, chan, mbox);
5743 #endif
5744                 }
5745                 break;
5746
5747         case ASYNC_LOOP_RESET:
5748                 /*
5749                  * This is a broadcast event that has to be sent across
5750                  * all active channels.
5751                  */
5752                 for (chan = 0; chan < isp->isp_nchan; chan++) {
5753                         fcp = FCPARAM(isp, chan);
5754                         if (fcp->role == ISP_ROLE_NONE)
5755                                 continue;
5756                         ISP_SET_SENDMARKER(isp, chan, 1);
5757                         if (fcp->isp_loopstate > LOOP_HAVE_LINK)
5758                                 fcp->isp_loopstate = LOOP_HAVE_LINK;
5759                         isp_async(isp, ISPASYNC_LOOP_RESET, chan);
5760 #ifdef  ISP_TARGET_MODE
5761                         isp_target_async(isp, chan, mbox);
5762 #endif
5763                 }
5764                 break;
5765
5766         case ASYNC_PDB_CHANGED:
5767         {
5768                 int echan, nphdl, nlstate, reason;
5769
5770                 if (IS_23XX(isp) || IS_24XX(isp)) {
5771                         nphdl = ISP_READ(isp, OUTMAILBOX1);
5772                         nlstate = ISP_READ(isp, OUTMAILBOX2);
5773                 } else {
5774                         nphdl = nlstate = 0xffff;
5775                 }
5776                 if (IS_24XX(isp))
5777                         reason = ISP_READ(isp, OUTMAILBOX3) >> 8;
5778                 else
5779                         reason = 0xff;
5780                 if (ISP_CAP_MULTI_ID(isp)) {
5781                         chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
5782                         if (chan == 0xff || nphdl == NIL_HANDLE) {
5783                                 chan = 0;
5784                                 echan = isp->isp_nchan - 1;
5785                         } else if (chan >= isp->isp_nchan) {
5786                                 break;
5787                         } else {
5788                                 echan = chan;
5789                         }
5790                 } else {
5791                         chan = echan = 0;
5792                 }
5793                 for (; chan <= echan; chan++) {
5794                         fcp = FCPARAM(isp, chan);
5795                         if (fcp->role == ISP_ROLE_NONE)
5796                                 continue;
5797                         if (fcp->isp_loopstate > LOOP_LTEST_DONE) {
5798                                 if (nphdl != NIL_HANDLE &&
5799                                     nphdl == fcp->isp_login_hdl &&
5800                                     reason == PDB24XX_AE_OPN_2)
5801                                         continue;
5802                                 fcp->isp_loopstate = LOOP_LTEST_DONE;
5803                         } else if (fcp->isp_loopstate < LOOP_HAVE_LINK)
5804                                 fcp->isp_loopstate = LOOP_HAVE_LINK;
5805                         isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
5806                             ISPASYNC_CHANGE_PDB, nphdl, nlstate, reason);
5807                 }
5808                 break;
5809         }
5810         case ASYNC_CHANGE_NOTIFY:
5811         {
5812                 int portid;
5813
5814                 portid = ((ISP_READ(isp, OUTMAILBOX1) & 0xff) << 16) |
5815                     ISP_READ(isp, OUTMAILBOX2);
5816                 if (ISP_CAP_MULTI_ID(isp)) {
5817                         chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
5818                         if (chan >= isp->isp_nchan)
5819                                 break;
5820                 } else {
5821                         chan = 0;
5822                 }
5823                 fcp = FCPARAM(isp, chan);
5824                 if (fcp->role == ISP_ROLE_NONE)
5825                         break;
5826                 if (fcp->isp_loopstate > LOOP_LTEST_DONE)
5827                         fcp->isp_loopstate = LOOP_LTEST_DONE;
5828                 else if (fcp->isp_loopstate < LOOP_HAVE_LINK)
5829                         fcp->isp_loopstate = LOOP_HAVE_LINK;
5830                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
5831                     ISPASYNC_CHANGE_SNS, portid);
5832                 break;
5833         }
5834         case ASYNC_ERR_LOGGING_DISABLED:
5835                 isp_prt(isp, ISP_LOGWARN, "Error logging disabled (reason 0x%x)",
5836                     ISP_READ(isp, OUTMAILBOX1));
5837                 break;
5838         case ASYNC_CONNMODE:
5839                 /*
5840                  * This only applies to 2100 amd 2200 cards
5841                  */
5842                 if (!IS_2200(isp) && !IS_2100(isp)) {
5843                         isp_prt(isp, ISP_LOGWARN, "bad card for ASYNC_CONNMODE event");
5844                         break;
5845                 }
5846                 chan = 0;
5847                 mbox = ISP_READ(isp, OUTMAILBOX1);
5848                 switch (mbox) {
5849                 case ISP_CONN_LOOP:
5850                         isp_prt(isp, ISP_LOGINFO,
5851                             "Point-to-Point -> Loop mode");
5852                         break;
5853                 case ISP_CONN_PTP:
5854                         isp_prt(isp, ISP_LOGINFO,
5855                             "Loop -> Point-to-Point mode");
5856                         break;
5857                 case ISP_CONN_BADLIP:
5858                         isp_prt(isp, ISP_LOGWARN,
5859                             "Point-to-Point -> Loop mode (BAD LIP)");
5860                         break;
5861                 case ISP_CONN_FATAL:
5862                         isp->isp_state = ISP_CRASHED;
5863                         isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
5864                         isp_async(isp, ISPASYNC_FW_CRASH);
5865                         return;
5866                 case ISP_CONN_LOOPBACK:
5867                         isp_prt(isp, ISP_LOGWARN,
5868                             "Looped Back in Point-to-Point mode");
5869                         break;
5870                 default:
5871                         isp_prt(isp, ISP_LOGWARN,
5872                             "Unknown connection mode (0x%x)", mbox);
5873                         break;
5874                 }
5875                 ISP_SET_SENDMARKER(isp, chan, 1);
5876                 FCPARAM(isp, chan)->isp_loopstate = LOOP_HAVE_LINK;
5877                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan, ISPASYNC_CHANGE_OTHER);
5878                 break;
5879         case ASYNC_P2P_INIT_ERR:
5880                 isp_prt(isp, ISP_LOGWARN, "P2P init error (reason 0x%x)",
5881                     ISP_READ(isp, OUTMAILBOX1));
5882                 break;
5883         case ASYNC_RCV_ERR:
5884                 if (IS_24XX(isp)) {
5885                         isp_prt(isp, ISP_LOGWARN, "Receive Error");
5886                 } else {
5887                         isp_prt(isp, ISP_LOGWARN, "unexpected ASYNC_RCV_ERR");
5888                 }
5889                 break;
5890         case ASYNC_RJT_SENT:    /* same as ASYNC_QFULL_SENT */
5891                 if (IS_24XX(isp)) {
5892                         isp_prt(isp, ISP_LOGTDEBUG0, "LS_RJT sent");
5893                         break;
5894                 } else {
5895                         isp_prt(isp, ISP_LOGTDEBUG0, "QFULL sent");
5896                         break;
5897                 }
5898         case ASYNC_FW_RESTART_COMPLETE:
5899                 isp_prt(isp, ISP_LOGDEBUG0, "FW restart complete");
5900                 break;
5901         case ASYNC_TEMPERATURE_ALERT:
5902                 isp_prt(isp, ISP_LOGERR, "Temperature alert (subcode 0x%x)",
5903                     ISP_READ(isp, OUTMAILBOX1));
5904                 break;
5905         case ASYNC_AUTOLOAD_FW_COMPLETE:
5906                 isp_prt(isp, ISP_LOGDEBUG0, "Autoload FW init complete");
5907                 break;
5908         case ASYNC_AUTOLOAD_FW_FAILURE:
5909                 isp_prt(isp, ISP_LOGERR, "Autoload FW init failure");
5910                 break;
5911         default:
5912                 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
5913                 break;
5914         }
5915 }
5916
5917 /*
5918  * Handle other response entries. A pointer to the request queue output
5919  * index is here in case we want to eat several entries at once, although
5920  * this is not used currently.
5921  */
5922
5923 static int
5924 isp_handle_other_response(ispsoftc_t *isp, int type, isphdr_t *hp, uint32_t *optrp)
5925 {
5926         isp_ridacq_t rid;
5927         int chan, c;
5928         uint32_t hdl, portid;
5929         void *ptr;
5930
5931         switch (type) {
5932         case RQSTYPE_MARKER:
5933                 isp_prt(isp, ISP_LOG_WARN1, "Marker Response");
5934                 return (1);
5935         case RQSTYPE_RPT_ID_ACQ:
5936                 isp_get_ridacq(isp, (isp_ridacq_t *)hp, &rid);
5937                 portid = (uint32_t)rid.ridacq_vp_port_hi << 16 |
5938                     rid.ridacq_vp_port_lo;
5939                 if (rid.ridacq_format == 0) {
5940                         for (chan = 0; chan < isp->isp_nchan; chan++) {
5941                                 fcparam *fcp = FCPARAM(isp, chan);
5942                                 if (fcp->role == ISP_ROLE_NONE)
5943                                         continue;
5944                                 c = (chan == 0) ? 127 : (chan - 1);
5945                                 if (rid.ridacq_map[c / 16] & (1 << (c % 16)) ||
5946                                     chan == 0) {
5947                                         fcp->isp_loopstate = LOOP_HAVE_LINK;
5948                                         isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
5949                                             chan, ISPASYNC_CHANGE_OTHER);
5950                                 } else {
5951                                         fcp->isp_loopstate = LOOP_NIL;
5952                                         isp_async(isp, ISPASYNC_LOOP_DOWN,
5953                                             chan);
5954                                 }
5955                         }
5956                 } else {
5957                         fcparam *fcp = FCPARAM(isp, rid.ridacq_vp_index);
5958                         if (rid.ridacq_vp_status == RIDACQ_STS_COMPLETE ||
5959                             rid.ridacq_vp_status == RIDACQ_STS_CHANGED) {
5960                                 fcp->isp_topo = (rid.ridacq_map[0] >> 9) & 0x7;
5961                                 fcp->isp_portid = portid;
5962                                 fcp->isp_loopstate = LOOP_HAVE_ADDR;
5963                                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
5964                                     rid.ridacq_vp_index, ISPASYNC_CHANGE_OTHER);
5965                         } else {
5966                                 fcp->isp_loopstate = LOOP_NIL;
5967                                 isp_async(isp, ISPASYNC_LOOP_DOWN,
5968                                     rid.ridacq_vp_index);
5969                         }
5970                 }
5971                 return (1);
5972         case RQSTYPE_CT_PASSTHRU:
5973         case RQSTYPE_VP_MODIFY:
5974         case RQSTYPE_VP_CTRL:
5975         case RQSTYPE_LOGIN:
5976                 ISP_IOXGET_32(isp, (uint32_t *)(hp + 1), hdl);
5977                 ptr = isp_find_xs(isp, hdl);
5978                 if (ptr != NULL) {
5979                         isp_destroy_handle(isp, hdl);
5980                         memcpy(ptr, hp, QENTRY_LEN);
5981                         wakeup(ptr);
5982                 }
5983                 return (1);
5984         case RQSTYPE_ATIO:
5985         case RQSTYPE_CTIO:
5986         case RQSTYPE_NOTIFY:
5987         case RQSTYPE_NOTIFY_ACK:
5988         case RQSTYPE_CTIO1:
5989         case RQSTYPE_ATIO2:
5990         case RQSTYPE_CTIO2:
5991         case RQSTYPE_CTIO3:
5992         case RQSTYPE_CTIO7:
5993         case RQSTYPE_ABTS_RCVD:
5994         case RQSTYPE_ABTS_RSP:
5995 #ifdef  ISP_TARGET_MODE
5996                 return (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp));
5997 #endif
5998                 /* FALLTHROUGH */
5999         case RQSTYPE_REQUEST:
6000         default:
6001                 return (0);
6002         }
6003 }
6004
6005 static void
6006 isp_parse_status(ispsoftc_t *isp, ispstatusreq_t *sp, XS_T *xs, uint32_t *rp)
6007 {
6008         switch (sp->req_completion_status & 0xff) {
6009         case RQCS_COMPLETE:
6010                 if (XS_NOERR(xs)) {
6011                         XS_SETERR(xs, HBA_NOERROR);
6012                 }
6013                 return;
6014
6015         case RQCS_INCOMPLETE:
6016                 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
6017                         isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Selection Timeout @ %s:%d", __func__, __LINE__);
6018                         if (XS_NOERR(xs)) {
6019                                 XS_SETERR(xs, HBA_SELTIMEOUT);
6020                                 *rp = XS_XFRLEN(xs);
6021                         }
6022                         return;
6023                 }
6024                 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Incomplete, state 0x%x", sp->req_state_flags);
6025                 break;
6026
6027         case RQCS_DMA_ERROR:
6028                 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA Error");
6029                 *rp = XS_XFRLEN(xs);
6030                 break;
6031
6032         case RQCS_TRANSPORT_ERROR:
6033         {
6034                 char buf[172];
6035                 ISP_SNPRINTF(buf, sizeof (buf), "states=>");
6036                 if (sp->req_state_flags & RQSF_GOT_BUS) {
6037                         ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_BUS", buf);
6038                 }
6039                 if (sp->req_state_flags & RQSF_GOT_TARGET) {
6040                         ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_TGT", buf);
6041                 }
6042                 if (sp->req_state_flags & RQSF_SENT_CDB) {
6043                         ISP_SNPRINTF(buf, sizeof (buf), "%s SENT_CDB", buf);
6044                 }
6045                 if (sp->req_state_flags & RQSF_XFRD_DATA) {
6046                         ISP_SNPRINTF(buf, sizeof (buf), "%s XFRD_DATA", buf);
6047                 }
6048                 if (sp->req_state_flags & RQSF_GOT_STATUS) {
6049                         ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_STS", buf);
6050                 }
6051                 if (sp->req_state_flags & RQSF_GOT_SENSE) {
6052                         ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_SNS", buf);
6053                 }
6054                 if (sp->req_state_flags & RQSF_XFER_COMPLETE) {
6055                         ISP_SNPRINTF(buf, sizeof (buf), "%s XFR_CMPLT", buf);
6056                 }
6057                 ISP_SNPRINTF(buf, sizeof (buf), "%s\nstatus=>", buf);
6058                 if (sp->req_status_flags & RQSTF_DISCONNECT) {
6059                         ISP_SNPRINTF(buf, sizeof (buf), "%s Disconnect", buf);
6060                 }
6061                 if (sp->req_status_flags & RQSTF_SYNCHRONOUS) {
6062                         ISP_SNPRINTF(buf, sizeof (buf), "%s Sync_xfr", buf);
6063                 }
6064                 if (sp->req_status_flags & RQSTF_PARITY_ERROR) {
6065                         ISP_SNPRINTF(buf, sizeof (buf), "%s Parity", buf);
6066                 }
6067                 if (sp->req_status_flags & RQSTF_BUS_RESET) {
6068                         ISP_SNPRINTF(buf, sizeof (buf), "%s Bus_Reset", buf);
6069                 }
6070                 if (sp->req_status_flags & RQSTF_DEVICE_RESET) {
6071                         ISP_SNPRINTF(buf, sizeof (buf), "%s Device_Reset", buf);
6072                 }
6073                 if (sp->req_status_flags & RQSTF_ABORTED) {
6074                         ISP_SNPRINTF(buf, sizeof (buf), "%s Aborted", buf);
6075                 }
6076                 if (sp->req_status_flags & RQSTF_TIMEOUT) {
6077                         ISP_SNPRINTF(buf, sizeof (buf), "%s Timeout", buf);
6078                 }
6079                 if (sp->req_status_flags & RQSTF_NEGOTIATION) {
6080                         ISP_SNPRINTF(buf, sizeof (buf), "%s Negotiation", buf);
6081                 }
6082                 isp_xs_prt(isp, xs,  ISP_LOGERR, "Transport Error: %s", buf);
6083                 *rp = XS_XFRLEN(xs);
6084                 break;
6085         }
6086         case RQCS_RESET_OCCURRED:
6087         {
6088                 int chan;
6089                 isp_xs_prt(isp, xs, ISP_LOGWARN, "Bus Reset destroyed command");
6090                 for (chan = 0; chan < isp->isp_nchan; chan++) {
6091                         FCPARAM(isp, chan)->sendmarker = 1;
6092                 }
6093                 if (XS_NOERR(xs)) {
6094                         XS_SETERR(xs, HBA_BUSRESET);
6095                 }
6096                 *rp = XS_XFRLEN(xs);
6097                 return;
6098         }
6099         case RQCS_ABORTED:
6100                 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
6101                 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
6102                 if (XS_NOERR(xs)) {
6103                         XS_SETERR(xs, HBA_ABORTED);
6104                 }
6105                 return;
6106
6107         case RQCS_TIMEOUT:
6108                 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command timed out");
6109                 /*
6110                  * XXX: Check to see if we logged out of the device.
6111                  */
6112                 if (XS_NOERR(xs)) {
6113                         XS_SETERR(xs, HBA_CMDTIMEOUT);
6114                 }
6115                 return;
6116
6117         case RQCS_DATA_OVERRUN:
6118                 XS_SET_RESID(xs, sp->req_resid);
6119                 isp_xs_prt(isp, xs, ISP_LOGERR, "data overrun (%ld)", (long) XS_GET_RESID(xs));
6120                 if (XS_NOERR(xs)) {
6121                         XS_SETERR(xs, HBA_DATAOVR);
6122                 }
6123                 return;
6124
6125         case RQCS_COMMAND_OVERRUN:
6126                 isp_xs_prt(isp, xs, ISP_LOGERR, "command overrun");
6127                 break;
6128
6129         case RQCS_STATUS_OVERRUN:
6130                 isp_xs_prt(isp, xs, ISP_LOGERR, "status overrun");
6131                 break;
6132
6133         case RQCS_BAD_MESSAGE:
6134                 isp_xs_prt(isp, xs, ISP_LOGERR, "msg not COMMAND COMPLETE after status");
6135                 break;
6136
6137         case RQCS_NO_MESSAGE_OUT:
6138                 isp_xs_prt(isp, xs, ISP_LOGERR, "No MESSAGE OUT phase after selection");
6139                 break;
6140
6141         case RQCS_EXT_ID_FAILED:
6142                 isp_xs_prt(isp, xs, ISP_LOGERR, "EXTENDED IDENTIFY failed");
6143                 break;
6144
6145         case RQCS_IDE_MSG_FAILED:
6146                 isp_xs_prt(isp, xs, ISP_LOGERR, "INITIATOR DETECTED ERROR rejected");
6147                 break;
6148
6149         case RQCS_ABORT_MSG_FAILED:
6150                 isp_xs_prt(isp, xs, ISP_LOGERR, "ABORT OPERATION rejected");
6151                 break;
6152
6153         case RQCS_REJECT_MSG_FAILED:
6154                 isp_xs_prt(isp, xs, ISP_LOGERR, "MESSAGE REJECT rejected");
6155                 break;
6156
6157         case RQCS_NOP_MSG_FAILED:
6158                 isp_xs_prt(isp, xs, ISP_LOGERR, "NOP rejected");
6159                 break;
6160
6161         case RQCS_PARITY_ERROR_MSG_FAILED:
6162                 isp_xs_prt(isp, xs, ISP_LOGERR, "MESSAGE PARITY ERROR rejected");
6163                 break;
6164
6165         case RQCS_DEVICE_RESET_MSG_FAILED:
6166                 isp_xs_prt(isp, xs, ISP_LOGWARN, "BUS DEVICE RESET rejected");
6167                 break;
6168
6169         case RQCS_ID_MSG_FAILED:
6170                 isp_xs_prt(isp, xs, ISP_LOGERR, "IDENTIFY rejected");
6171                 break;
6172
6173         case RQCS_UNEXP_BUS_FREE:
6174                 isp_xs_prt(isp, xs, ISP_LOGERR, "Unexpected Bus Free");
6175                 break;
6176
6177         case RQCS_DATA_UNDERRUN:
6178         {
6179                 if (IS_FC(isp)) {
6180                         int ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
6181                         if (!ru_marked || sp->req_resid > XS_XFRLEN(xs)) {
6182                                 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6183                                 if (XS_NOERR(xs)) {
6184                                         XS_SETERR(xs, HBA_BOTCH);
6185                                 }
6186                                 return;
6187                         }
6188                 }
6189                 XS_SET_RESID(xs, sp->req_resid);
6190                 if (XS_NOERR(xs)) {
6191                         XS_SETERR(xs, HBA_NOERROR);
6192                 }
6193                 return;
6194         }
6195
6196         case RQCS_XACT_ERR1:
6197                 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued transaction with disconnect not set");
6198                 break;
6199
6200         case RQCS_XACT_ERR2:
6201                 isp_xs_prt(isp, xs, ISP_LOGERR,
6202                     "HBA attempted queued transaction to target routine %jx",
6203                     (uintmax_t)XS_LUN(xs));
6204                 break;
6205
6206         case RQCS_XACT_ERR3:
6207                 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued cmd when queueing disabled");
6208                 break;
6209
6210         case RQCS_BAD_ENTRY:
6211                 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
6212                 break;
6213
6214         case RQCS_QUEUE_FULL:
6215                 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "internal queues full status 0x%x", *XS_STSP(xs));
6216
6217                 /*
6218                  * If QFULL or some other status byte is set, then this
6219                  * isn't an error, per se.
6220                  *
6221                  * Unfortunately, some QLogic f/w writers have, in
6222                  * some cases, omitted to *set* status to QFULL.
6223                  */
6224 #if     0
6225                 if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
6226                         XS_SETERR(xs, HBA_NOERROR);
6227                         return;
6228                 }
6229
6230 #endif
6231                 *XS_STSP(xs) = SCSI_QFULL;
6232                 XS_SETERR(xs, HBA_NOERROR);
6233                 return;
6234
6235         case RQCS_PHASE_SKIPPED:
6236                 isp_xs_prt(isp, xs, ISP_LOGERR, "SCSI phase skipped");
6237                 break;
6238
6239         case RQCS_ARQS_FAILED:
6240                 isp_xs_prt(isp, xs, ISP_LOGERR, "Auto Request Sense Failed");
6241                 if (XS_NOERR(xs)) {
6242                         XS_SETERR(xs, HBA_ARQFAIL);
6243                 }
6244                 return;
6245
6246         case RQCS_WIDE_FAILED:
6247                 isp_xs_prt(isp, xs, ISP_LOGERR, "Wide Negotiation Failed");
6248                 if (IS_SCSI(isp)) {
6249                         sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
6250                         sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_WIDE;
6251                         sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
6252                         sdp->update = 1;
6253                 }
6254                 if (XS_NOERR(xs)) {
6255                         XS_SETERR(xs, HBA_NOERROR);
6256                 }
6257                 return;
6258
6259         case RQCS_SYNCXFER_FAILED:
6260                 isp_xs_prt(isp, xs, ISP_LOGERR, "SDTR Message Failed");
6261                 if (IS_SCSI(isp)) {
6262                         sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
6263                         sdp += XS_CHANNEL(xs);
6264                         sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_SYNC;
6265                         sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
6266                         sdp->update = 1;
6267                 }
6268                 break;
6269
6270         case RQCS_LVD_BUSERR:
6271                 isp_xs_prt(isp, xs, ISP_LOGERR, "Bad LVD condition");
6272                 break;
6273
6274         case RQCS_PORT_UNAVAILABLE:
6275                 /*
6276                  * No such port on the loop. Moral equivalent of SELTIMEO
6277                  */
6278         case RQCS_PORT_LOGGED_OUT:
6279         {
6280                 const char *reason;
6281                 uint8_t sts = sp->req_completion_status & 0xff;
6282                 fcparam *fcp = FCPARAM(isp, 0);
6283                 fcportdb_t *lp;
6284
6285                 /*
6286                  * It was there (maybe)- treat as a selection timeout.
6287                  */
6288                 if (sts == RQCS_PORT_UNAVAILABLE) {
6289                         reason = "unavailable";
6290                 } else {
6291                         reason = "logout";
6292                 }
6293
6294                 isp_prt(isp, ISP_LOGINFO, "port %s for target %d", reason, XS_TGT(xs));
6295
6296                 /* XXX: Should we trigger rescan or FW announce change? */
6297
6298                 if (XS_NOERR(xs)) {
6299                         lp = &fcp->portdb[XS_TGT(xs)];
6300                         if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
6301                                 *XS_STSP(xs) = SCSI_BUSY;
6302                                 XS_SETERR(xs, HBA_TGTBSY);
6303                         } else
6304                                 XS_SETERR(xs, HBA_SELTIMEOUT);
6305                 }
6306                 return;
6307         }
6308         case RQCS_PORT_CHANGED:
6309                 isp_prt(isp, ISP_LOGWARN, "port changed for target %d", XS_TGT(xs));
6310                 if (XS_NOERR(xs)) {
6311                         *XS_STSP(xs) = SCSI_BUSY;
6312                         XS_SETERR(xs, HBA_TGTBSY);
6313                 }
6314                 return;
6315
6316         case RQCS_PORT_BUSY:
6317                 isp_prt(isp, ISP_LOGWARN, "port busy for target %d", XS_TGT(xs));
6318                 if (XS_NOERR(xs)) {
6319                         *XS_STSP(xs) = SCSI_BUSY;
6320                         XS_SETERR(xs, HBA_TGTBSY);
6321                 }
6322                 return;
6323
6324         default:
6325                 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x", sp->req_completion_status);
6326                 break;
6327         }
6328         if (XS_NOERR(xs)) {
6329                 XS_SETERR(xs, HBA_BOTCH);
6330         }
6331 }
6332
6333 static void
6334 isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp, XS_T *xs, uint32_t *rp)
6335 {
6336         int ru_marked, sv_marked;
6337         int chan = XS_CHANNEL(xs);
6338
6339         switch (sp->req_completion_status) {
6340         case RQCS_COMPLETE:
6341                 if (XS_NOERR(xs)) {
6342                         XS_SETERR(xs, HBA_NOERROR);
6343                 }
6344                 return;
6345
6346         case RQCS_DMA_ERROR:
6347                 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA error");
6348                 break;
6349
6350         case RQCS_TRANSPORT_ERROR:
6351                 isp_xs_prt(isp, xs,  ISP_LOGERR, "Transport Error");
6352                 break;
6353
6354         case RQCS_RESET_OCCURRED:
6355                 isp_xs_prt(isp, xs, ISP_LOGWARN, "reset destroyed command");
6356                 FCPARAM(isp, chan)->sendmarker = 1;
6357                 if (XS_NOERR(xs)) {
6358                         XS_SETERR(xs, HBA_BUSRESET);
6359                 }
6360                 return;
6361
6362         case RQCS_ABORTED:
6363                 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
6364                 FCPARAM(isp, chan)->sendmarker = 1;
6365                 if (XS_NOERR(xs)) {
6366                         XS_SETERR(xs, HBA_ABORTED);
6367                 }
6368                 return;
6369
6370         case RQCS_TIMEOUT:
6371                 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command Timed Out");
6372                 if (XS_NOERR(xs)) {
6373                         XS_SETERR(xs, HBA_CMDTIMEOUT);
6374                 }
6375                 return;
6376
6377         case RQCS_DATA_OVERRUN:
6378                 XS_SET_RESID(xs, sp->req_resid);
6379                 isp_xs_prt(isp, xs, ISP_LOGERR, "Data Overrun");
6380                 if (XS_NOERR(xs)) {
6381                         XS_SETERR(xs, HBA_DATAOVR);
6382                 }
6383                 return;
6384
6385         case RQCS_24XX_DRE:     /* data reassembly error */
6386                 isp_prt(isp, ISP_LOGERR, "Chan %d data reassembly error for target %d", chan, XS_TGT(xs));
6387                 if (XS_NOERR(xs)) {
6388                         XS_SETERR(xs, HBA_ABORTED);
6389                 }
6390                 *rp = XS_XFRLEN(xs);
6391                 return;
6392
6393         case RQCS_24XX_TABORT:  /* aborted by target */
6394                 isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS", chan, XS_TGT(xs));
6395                 if (XS_NOERR(xs)) {
6396                         XS_SETERR(xs, HBA_ABORTED);
6397                 }
6398                 return;
6399
6400         case RQCS_DATA_UNDERRUN:
6401                 ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
6402                 /*
6403                  * We can get an underrun w/o things being marked
6404                  * if we got a non-zero status.
6405                  */
6406                 sv_marked = (sp->req_scsi_status & (RQCS_SV|RQCS_RV)) != 0;
6407                 if ((ru_marked == 0 && sv_marked == 0) ||
6408                     (sp->req_resid > XS_XFRLEN(xs))) {
6409                         isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6410                         if (XS_NOERR(xs)) {
6411                                 XS_SETERR(xs, HBA_BOTCH);
6412                         }
6413                         return;
6414                 }
6415                 XS_SET_RESID(xs, sp->req_resid);
6416                 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
6417                 if (XS_NOERR(xs)) {
6418                         XS_SETERR(xs, HBA_NOERROR);
6419                 }
6420                 return;
6421
6422         case RQCS_PORT_UNAVAILABLE:
6423                 /*
6424                  * No such port on the loop. Moral equivalent of SELTIMEO
6425                  */
6426         case RQCS_PORT_LOGGED_OUT:
6427         {
6428                 const char *reason;
6429                 uint8_t sts = sp->req_completion_status & 0xff;
6430                 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
6431                 fcportdb_t *lp;
6432
6433                 /*
6434                  * It was there (maybe)- treat as a selection timeout.
6435                  */
6436                 if (sts == RQCS_PORT_UNAVAILABLE) {
6437                         reason = "unavailable";
6438                 } else {
6439                         reason = "logout";
6440                 }
6441
6442                 isp_prt(isp, ISP_LOGINFO, "Chan %d port %s for target %d",
6443                     chan, reason, XS_TGT(xs));
6444
6445                 /* XXX: Should we trigger rescan or FW announce change? */
6446
6447                 if (XS_NOERR(xs)) {
6448                         lp = &fcp->portdb[XS_TGT(xs)];
6449                         if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
6450                                 *XS_STSP(xs) = SCSI_BUSY;
6451                                 XS_SETERR(xs, HBA_TGTBSY);
6452                         } else
6453                                 XS_SETERR(xs, HBA_SELTIMEOUT);
6454                 }
6455                 return;
6456         }
6457         case RQCS_PORT_CHANGED:
6458                 isp_prt(isp, ISP_LOGWARN, "port changed for target %d chan %d", XS_TGT(xs), chan);
6459                 if (XS_NOERR(xs)) {
6460                         *XS_STSP(xs) = SCSI_BUSY;
6461                         XS_SETERR(xs, HBA_TGTBSY);
6462                 }
6463                 return;
6464
6465         case RQCS_24XX_ENOMEM:  /* f/w resource unavailable */
6466                 isp_prt(isp, ISP_LOGWARN, "f/w resource unavailable for target %d chan %d", XS_TGT(xs), chan);
6467                 if (XS_NOERR(xs)) {
6468                         *XS_STSP(xs) = SCSI_BUSY;
6469                         XS_SETERR(xs, HBA_TGTBSY);
6470                 }
6471                 return;
6472
6473         case RQCS_24XX_TMO:     /* task management overrun */
6474                 isp_prt(isp, ISP_LOGWARN, "command for target %d overlapped task management for chan %d", XS_TGT(xs), chan);
6475                 if (XS_NOERR(xs)) {
6476                         *XS_STSP(xs) = SCSI_BUSY;
6477                         XS_SETERR(xs, HBA_TGTBSY);
6478                 }
6479                 return;
6480
6481         default:
6482                 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x on chan %d", sp->req_completion_status, chan);
6483                 break;
6484         }
6485         if (XS_NOERR(xs)) {
6486                 XS_SETERR(xs, HBA_BOTCH);
6487         }
6488 }
6489
6490 static void
6491 isp_fastpost_complete(ispsoftc_t *isp, uint32_t fph)
6492 {
6493         XS_T *xs;
6494
6495         if (fph == 0) {
6496                 return;
6497         }
6498         xs = isp_find_xs(isp, fph);
6499         if (xs == NULL) {
6500                 isp_prt(isp, ISP_LOGWARN,
6501                     "Command for fast post handle 0x%x not found", fph);
6502                 return;
6503         }
6504         isp_destroy_handle(isp, fph);
6505
6506         /*
6507          * Since we don't have a result queue entry item,
6508          * we must believe that SCSI status is zero and
6509          * that all data transferred.
6510          */
6511         XS_SET_RESID(xs, 0);
6512         *XS_STSP(xs) = SCSI_GOOD;
6513         if (XS_XFRLEN(xs)) {
6514                 ISP_DMAFREE(isp, xs, fph);
6515         }
6516         isp_done(xs);
6517 }
6518
6519 #define ISP_SCSI_IBITS(op)              (mbpscsi[((op)<<1)])
6520 #define ISP_SCSI_OBITS(op)              (mbpscsi[((op)<<1) + 1])
6521 #define ISP_SCSI_OPMAP(in, out)         in, out
6522 static const uint8_t mbpscsi[] = {
6523         ISP_SCSI_OPMAP(0x01, 0x01),     /* 0x00: MBOX_NO_OP */
6524         ISP_SCSI_OPMAP(0x1f, 0x01),     /* 0x01: MBOX_LOAD_RAM */
6525         ISP_SCSI_OPMAP(0x03, 0x01),     /* 0x02: MBOX_EXEC_FIRMWARE */
6526         ISP_SCSI_OPMAP(0x1f, 0x01),     /* 0x03: MBOX_DUMP_RAM */
6527         ISP_SCSI_OPMAP(0x07, 0x07),     /* 0x04: MBOX_WRITE_RAM_WORD */
6528         ISP_SCSI_OPMAP(0x03, 0x07),     /* 0x05: MBOX_READ_RAM_WORD */
6529         ISP_SCSI_OPMAP(0x3f, 0x3f),     /* 0x06: MBOX_MAILBOX_REG_TEST */
6530         ISP_SCSI_OPMAP(0x07, 0x07),     /* 0x07: MBOX_VERIFY_CHECKSUM   */
6531         ISP_SCSI_OPMAP(0x01, 0x0f),     /* 0x08: MBOX_ABOUT_FIRMWARE */
6532         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x09: */
6533         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x0a: */
6534         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x0b: */
6535         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x0c: */
6536         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x0d: */
6537         ISP_SCSI_OPMAP(0x01, 0x05),     /* 0x0e: MBOX_CHECK_FIRMWARE */
6538         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x0f: */
6539         ISP_SCSI_OPMAP(0x1f, 0x1f),     /* 0x10: MBOX_INIT_REQ_QUEUE */
6540         ISP_SCSI_OPMAP(0x3f, 0x3f),     /* 0x11: MBOX_INIT_RES_QUEUE */
6541         ISP_SCSI_OPMAP(0x0f, 0x0f),     /* 0x12: MBOX_EXECUTE_IOCB */
6542         ISP_SCSI_OPMAP(0x03, 0x03),     /* 0x13: MBOX_WAKE_UP   */
6543         ISP_SCSI_OPMAP(0x01, 0x3f),     /* 0x14: MBOX_STOP_FIRMWARE */
6544         ISP_SCSI_OPMAP(0x0f, 0x0f),     /* 0x15: MBOX_ABORT */
6545         ISP_SCSI_OPMAP(0x03, 0x03),     /* 0x16: MBOX_ABORT_DEVICE */
6546         ISP_SCSI_OPMAP(0x07, 0x07),     /* 0x17: MBOX_ABORT_TARGET */
6547         ISP_SCSI_OPMAP(0x07, 0x07),     /* 0x18: MBOX_BUS_RESET */
6548         ISP_SCSI_OPMAP(0x03, 0x07),     /* 0x19: MBOX_STOP_QUEUE */
6549         ISP_SCSI_OPMAP(0x03, 0x07),     /* 0x1a: MBOX_START_QUEUE */
6550         ISP_SCSI_OPMAP(0x03, 0x07),     /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6551         ISP_SCSI_OPMAP(0x03, 0x07),     /* 0x1c: MBOX_ABORT_QUEUE */
6552         ISP_SCSI_OPMAP(0x03, 0x4f),     /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6553         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x1e: */
6554         ISP_SCSI_OPMAP(0x01, 0x07),     /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6555         ISP_SCSI_OPMAP(0x01, 0x07),     /* 0x20: MBOX_GET_INIT_SCSI_ID */
6556         ISP_SCSI_OPMAP(0x01, 0x07),     /* 0x21: MBOX_GET_SELECT_TIMEOUT */
6557         ISP_SCSI_OPMAP(0x01, 0xc7),     /* 0x22: MBOX_GET_RETRY_COUNT   */
6558         ISP_SCSI_OPMAP(0x01, 0x07),     /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
6559         ISP_SCSI_OPMAP(0x01, 0x03),     /* 0x24: MBOX_GET_CLOCK_RATE */
6560         ISP_SCSI_OPMAP(0x01, 0x07),     /* 0x25: MBOX_GET_ACT_NEG_STATE */
6561         ISP_SCSI_OPMAP(0x01, 0x07),     /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
6562         ISP_SCSI_OPMAP(0x01, 0x07),     /* 0x27: MBOX_GET_PCI_PARAMS */
6563         ISP_SCSI_OPMAP(0x03, 0x4f),     /* 0x28: MBOX_GET_TARGET_PARAMS */
6564         ISP_SCSI_OPMAP(0x03, 0x0f),     /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
6565         ISP_SCSI_OPMAP(0x01, 0x07),     /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */
6566         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x2b: */
6567         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x2c: */
6568         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x2d: */
6569         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x2e: */
6570         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x2f: */
6571         ISP_SCSI_OPMAP(0x03, 0x03),     /* 0x30: MBOX_SET_INIT_SCSI_ID */
6572         ISP_SCSI_OPMAP(0x07, 0x07),     /* 0x31: MBOX_SET_SELECT_TIMEOUT */
6573         ISP_SCSI_OPMAP(0xc7, 0xc7),     /* 0x32: MBOX_SET_RETRY_COUNT   */
6574         ISP_SCSI_OPMAP(0x07, 0x07),     /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
6575         ISP_SCSI_OPMAP(0x03, 0x03),     /* 0x34: MBOX_SET_CLOCK_RATE */
6576         ISP_SCSI_OPMAP(0x07, 0x07),     /* 0x35: MBOX_SET_ACT_NEG_STATE */
6577         ISP_SCSI_OPMAP(0x07, 0x07),     /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
6578         ISP_SCSI_OPMAP(0x07, 0x07),     /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
6579         ISP_SCSI_OPMAP(0x4f, 0x4f),     /* 0x38: MBOX_SET_TARGET_PARAMS */
6580         ISP_SCSI_OPMAP(0x0f, 0x0f),     /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
6581         ISP_SCSI_OPMAP(0x07, 0x07),     /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */
6582         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x3b: */
6583         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x3c: */
6584         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x3d: */
6585         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x3e: */
6586         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x3f: */
6587         ISP_SCSI_OPMAP(0x01, 0x03),     /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
6588         ISP_SCSI_OPMAP(0x3f, 0x01),     /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
6589         ISP_SCSI_OPMAP(0x03, 0x07),     /* 0x42: MBOX_EXEC_BIOS_IOCB */
6590         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x43: */
6591         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x44: */
6592         ISP_SCSI_OPMAP(0x03, 0x03),     /* 0x45: SET SYSTEM PARAMETER */
6593         ISP_SCSI_OPMAP(0x01, 0x03),     /* 0x46: GET SYSTEM PARAMETER */
6594         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x47: */
6595         ISP_SCSI_OPMAP(0x01, 0xcf),     /* 0x48: GET SCAM CONFIGURATION */
6596         ISP_SCSI_OPMAP(0xcf, 0xcf),     /* 0x49: SET SCAM CONFIGURATION */
6597         ISP_SCSI_OPMAP(0x03, 0x03),     /* 0x4a: MBOX_SET_FIRMWARE_FEATURES */
6598         ISP_SCSI_OPMAP(0x01, 0x03),     /* 0x4b: MBOX_GET_FIRMWARE_FEATURES */
6599         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x4c: */
6600         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x4d: */
6601         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x4e: */
6602         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x4f: */
6603         ISP_SCSI_OPMAP(0xdf, 0xdf),     /* 0x50: LOAD RAM A64 */
6604         ISP_SCSI_OPMAP(0xdf, 0xdf),     /* 0x51: DUMP RAM A64 */
6605         ISP_SCSI_OPMAP(0xdf, 0xff),     /* 0x52: INITIALIZE REQUEST QUEUE A64 */
6606         ISP_SCSI_OPMAP(0xef, 0xff),     /* 0x53: INITIALIZE RESPONSE QUEUE A64 */
6607         ISP_SCSI_OPMAP(0xcf, 0x01),     /* 0x54: EXECUCUTE COMMAND IOCB A64 */
6608         ISP_SCSI_OPMAP(0x07, 0x01),     /* 0x55: ENABLE TARGET MODE */
6609         ISP_SCSI_OPMAP(0x03, 0x0f),     /* 0x56: GET TARGET STATUS */
6610         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x57: */
6611         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x58: */
6612         ISP_SCSI_OPMAP(0x00, 0x00),     /* 0x59: */
6613         ISP_SCSI_OPMAP(0x03, 0x03),     /* 0x5a: SET DATA OVERRUN RECOVERY MODE */
6614         ISP_SCSI_OPMAP(0x01, 0x03),     /* 0x5b: GET DATA OVERRUN RECOVERY MODE */
6615         ISP_SCSI_OPMAP(0x0f, 0x0f),     /* 0x5c: SET HOST DATA */
6616         ISP_SCSI_OPMAP(0x01, 0x01)      /* 0x5d: GET NOST DATA */
6617 };
6618 #define MAX_SCSI_OPCODE 0x5d
6619
6620 static const char *scsi_mbcmd_names[] = {
6621         "NO-OP",
6622         "LOAD RAM",
6623         "EXEC FIRMWARE",
6624         "DUMP RAM",
6625         "WRITE RAM WORD",
6626         "READ RAM WORD",
6627         "MAILBOX REG TEST",
6628         "VERIFY CHECKSUM",
6629         "ABOUT FIRMWARE",
6630         NULL,
6631         NULL,
6632         NULL,
6633         NULL,
6634         NULL,
6635         "CHECK FIRMWARE",
6636         NULL,
6637         "INIT REQUEST QUEUE",
6638         "INIT RESULT QUEUE",
6639         "EXECUTE IOCB",
6640         "WAKE UP",
6641         "STOP FIRMWARE",
6642         "ABORT",
6643         "ABORT DEVICE",
6644         "ABORT TARGET",
6645         "BUS RESET",
6646         "STOP QUEUE",
6647         "START QUEUE",
6648         "SINGLE STEP QUEUE",
6649         "ABORT QUEUE",
6650         "GET DEV QUEUE STATUS",
6651         NULL,
6652         "GET FIRMWARE STATUS",
6653         "GET INIT SCSI ID",
6654         "GET SELECT TIMEOUT",
6655         "GET RETRY COUNT",
6656         "GET TAG AGE LIMIT",
6657         "GET CLOCK RATE",
6658         "GET ACT NEG STATE",
6659         "GET ASYNC DATA SETUP TIME",
6660         "GET PCI PARAMS",
6661         "GET TARGET PARAMS",
6662         "GET DEV QUEUE PARAMS",
6663         "GET RESET DELAY PARAMS",
6664         NULL,
6665         NULL,
6666         NULL,
6667         NULL,
6668         NULL,
6669         "SET INIT SCSI ID",
6670         "SET SELECT TIMEOUT",
6671         "SET RETRY COUNT",
6672         "SET TAG AGE LIMIT",
6673         "SET CLOCK RATE",
6674         "SET ACT NEG STATE",
6675         "SET ASYNC DATA SETUP TIME",
6676         "SET PCI CONTROL PARAMS",
6677         "SET TARGET PARAMS",
6678         "SET DEV QUEUE PARAMS",
6679         "SET RESET DELAY PARAMS",
6680         NULL,
6681         NULL,
6682         NULL,
6683         NULL,
6684         NULL,
6685         "RETURN BIOS BLOCK ADDR",
6686         "WRITE FOUR RAM WORDS",
6687         "EXEC BIOS IOCB",
6688         NULL,
6689         NULL,
6690         "SET SYSTEM PARAMETER",
6691         "GET SYSTEM PARAMETER",
6692         NULL,
6693         "GET SCAM CONFIGURATION",
6694         "SET SCAM CONFIGURATION",
6695         "SET FIRMWARE FEATURES",
6696         "GET FIRMWARE FEATURES",
6697         NULL,
6698         NULL,
6699         NULL,
6700         NULL,
6701         "LOAD RAM A64",
6702         "DUMP RAM A64",
6703         "INITIALIZE REQUEST QUEUE A64",
6704         "INITIALIZE RESPONSE QUEUE A64",
6705         "EXECUTE IOCB A64",
6706         "ENABLE TARGET MODE",
6707         "GET TARGET MODE STATE",
6708         NULL,
6709         NULL,
6710         NULL,
6711         "SET DATA OVERRUN RECOVERY MODE",
6712         "GET DATA OVERRUN RECOVERY MODE",
6713         "SET HOST DATA",
6714         "GET NOST DATA",
6715 };
6716
6717 #define ISP_FC_IBITS(op)        ((mbpfc[((op)<<3) + 0] << 24) | (mbpfc[((op)<<3) + 1] << 16) | (mbpfc[((op)<<3) + 2] << 8) | (mbpfc[((op)<<3) + 3]))
6718 #define ISP_FC_OBITS(op)        ((mbpfc[((op)<<3) + 4] << 24) | (mbpfc[((op)<<3) + 5] << 16) | (mbpfc[((op)<<3) + 6] << 8) | (mbpfc[((op)<<3) + 7]))
6719
6720 #define ISP_FC_OPMAP(in0, out0)                                                   0,   0,   0, in0,    0,    0,    0, out0
6721 #define ISP_FC_OPMAP_HALF(in1, in0, out1, out0)                                   0,   0, in1, in0,    0,    0, out1, out0
6722 #define ISP_FC_OPMAP_FULL(in3, in2, in1, in0, out3, out2, out1, out0)           in3, in2, in1, in0, out3, out2, out1, out0
6723 static const uint32_t mbpfc[] = {
6724         ISP_FC_OPMAP(0x01, 0x01),       /* 0x00: MBOX_NO_OP */
6725         ISP_FC_OPMAP(0x1f, 0x01),       /* 0x01: MBOX_LOAD_RAM */
6726         ISP_FC_OPMAP_HALF(0x07, 0xff, 0x00, 0x03),      /* 0x02: MBOX_EXEC_FIRMWARE */
6727         ISP_FC_OPMAP(0xdf, 0x01),       /* 0x03: MBOX_DUMP_RAM */
6728         ISP_FC_OPMAP(0x07, 0x07),       /* 0x04: MBOX_WRITE_RAM_WORD */
6729         ISP_FC_OPMAP(0x03, 0x07),       /* 0x05: MBOX_READ_RAM_WORD */
6730         ISP_FC_OPMAP_FULL(0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff),      /* 0x06: MBOX_MAILBOX_REG_TEST */
6731         ISP_FC_OPMAP(0x07, 0x07),       /* 0x07: MBOX_VERIFY_CHECKSUM   */
6732         ISP_FC_OPMAP_FULL(0x0, 0x0, 0x0, 0x01, 0x0, 0x3, 0x80, 0x7f),   /* 0x08: MBOX_ABOUT_FIRMWARE */
6733         ISP_FC_OPMAP(0xdf, 0x01),       /* 0x09: MBOX_LOAD_RISC_RAM_2100 */
6734         ISP_FC_OPMAP(0xdf, 0x01),       /* 0x0a: DUMP RAM */
6735         ISP_FC_OPMAP_HALF(0x1, 0xff, 0x0, 0x01),        /* 0x0b: MBOX_LOAD_RISC_RAM */
6736         ISP_FC_OPMAP(0x00, 0x00),       /* 0x0c: */
6737         ISP_FC_OPMAP_HALF(0x1, 0x0f, 0x0, 0x01),        /* 0x0d: MBOX_WRITE_RAM_WORD_EXTENDED */
6738         ISP_FC_OPMAP(0x01, 0x05),       /* 0x0e: MBOX_CHECK_FIRMWARE */
6739         ISP_FC_OPMAP_HALF(0x1, 0x03, 0x0, 0x0d),        /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED */
6740         ISP_FC_OPMAP(0x1f, 0x11),       /* 0x10: MBOX_INIT_REQ_QUEUE */
6741         ISP_FC_OPMAP(0x2f, 0x21),       /* 0x11: MBOX_INIT_RES_QUEUE */
6742         ISP_FC_OPMAP(0x0f, 0x01),       /* 0x12: MBOX_EXECUTE_IOCB */
6743         ISP_FC_OPMAP(0x03, 0x03),       /* 0x13: MBOX_WAKE_UP   */
6744         ISP_FC_OPMAP_HALF(0x1, 0xff, 0x0, 0x03),        /* 0x14: MBOX_STOP_FIRMWARE */
6745         ISP_FC_OPMAP(0x4f, 0x01),       /* 0x15: MBOX_ABORT */
6746         ISP_FC_OPMAP(0x07, 0x01),       /* 0x16: MBOX_ABORT_DEVICE */
6747         ISP_FC_OPMAP(0x07, 0x01),       /* 0x17: MBOX_ABORT_TARGET */
6748         ISP_FC_OPMAP(0x03, 0x03),       /* 0x18: MBOX_BUS_RESET */
6749         ISP_FC_OPMAP(0x07, 0x05),       /* 0x19: MBOX_STOP_QUEUE */
6750         ISP_FC_OPMAP(0x07, 0x05),       /* 0x1a: MBOX_START_QUEUE */
6751         ISP_FC_OPMAP(0x07, 0x05),       /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6752         ISP_FC_OPMAP(0x07, 0x05),       /* 0x1c: MBOX_ABORT_QUEUE */
6753         ISP_FC_OPMAP(0x07, 0x03),       /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6754         ISP_FC_OPMAP(0x00, 0x00),       /* 0x1e: */
6755         ISP_FC_OPMAP(0x01, 0x07),       /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6756         ISP_FC_OPMAP_HALF(0x2, 0x01, 0x7e, 0xcf),       /* 0x20: MBOX_GET_LOOP_ID */
6757         ISP_FC_OPMAP(0x00, 0x00),       /* 0x21: */
6758         ISP_FC_OPMAP(0x03, 0x4b),       /* 0x22: MBOX_GET_TIMEOUT_PARAMS */
6759         ISP_FC_OPMAP(0x00, 0x00),       /* 0x23: */
6760         ISP_FC_OPMAP(0x00, 0x00),       /* 0x24: */
6761         ISP_FC_OPMAP(0x00, 0x00),       /* 0x25: */
6762         ISP_FC_OPMAP(0x00, 0x00),       /* 0x26: */
6763         ISP_FC_OPMAP(0x00, 0x00),       /* 0x27: */
6764         ISP_FC_OPMAP(0x01, 0x03),       /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */
6765         ISP_FC_OPMAP(0x03, 0x07),       /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */
6766         ISP_FC_OPMAP(0x00, 0x00),       /* 0x2a: */
6767         ISP_FC_OPMAP(0x00, 0x00),       /* 0x2b: */
6768         ISP_FC_OPMAP(0x00, 0x00),       /* 0x2c: */
6769         ISP_FC_OPMAP(0x00, 0x00),       /* 0x2d: */
6770         ISP_FC_OPMAP(0x00, 0x00),       /* 0x2e: */
6771         ISP_FC_OPMAP(0x00, 0x00),       /* 0x2f: */
6772         ISP_FC_OPMAP(0x00, 0x00),       /* 0x30: */
6773         ISP_FC_OPMAP(0x00, 0x00),       /* 0x31: */
6774         ISP_FC_OPMAP(0x4b, 0x4b),       /* 0x32: MBOX_SET_TIMEOUT_PARAMS */
6775         ISP_FC_OPMAP(0x00, 0x00),       /* 0x33: */
6776         ISP_FC_OPMAP(0x00, 0x00),       /* 0x34: */
6777         ISP_FC_OPMAP(0x00, 0x00),       /* 0x35: */
6778         ISP_FC_OPMAP(0x00, 0x00),       /* 0x36: */
6779         ISP_FC_OPMAP(0x00, 0x00),       /* 0x37: */
6780         ISP_FC_OPMAP(0x0f, 0x01),       /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */
6781         ISP_FC_OPMAP(0x0f, 0x07),       /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */
6782         ISP_FC_OPMAP(0x00, 0x00),       /* 0x3a: */
6783         ISP_FC_OPMAP(0x00, 0x00),       /* 0x3b: */
6784         ISP_FC_OPMAP(0x00, 0x00),       /* 0x3c: */
6785         ISP_FC_OPMAP(0x00, 0x00),       /* 0x3d: */
6786         ISP_FC_OPMAP(0x00, 0x00),       /* 0x3e: */
6787         ISP_FC_OPMAP(0x00, 0x00),       /* 0x3f: */
6788         ISP_FC_OPMAP(0x03, 0x01),       /* 0x40: MBOX_LOOP_PORT_BYPASS */
6789         ISP_FC_OPMAP(0x03, 0x01),       /* 0x41: MBOX_LOOP_PORT_ENABLE */
6790         ISP_FC_OPMAP_HALF(0x0, 0x01, 0x1f, 0xcf),       /* 0x42: MBOX_GET_RESOURCE_COUNT */
6791         ISP_FC_OPMAP(0x01, 0x01),       /* 0x43: MBOX_REQUEST_OFFLINE_MODE */
6792         ISP_FC_OPMAP(0x00, 0x00),       /* 0x44: */
6793         ISP_FC_OPMAP(0x00, 0x00),       /* 0x45: */
6794         ISP_FC_OPMAP(0x00, 0x00),       /* 0x46: */
6795         ISP_FC_OPMAP(0xcf, 0x03),       /* 0x47: GET PORT_DATABASE ENHANCED */
6796         ISP_FC_OPMAP(0xcf, 0x0f),       /* 0x48: MBOX_INIT_FIRMWARE_MULTI_ID */
6797         ISP_FC_OPMAP(0xcd, 0x01),       /* 0x49: MBOX_GET_VP_DATABASE */
6798         ISP_FC_OPMAP_HALF(0x2, 0xcd, 0x0, 0x01),        /* 0x4a: MBOX_GET_VP_DATABASE_ENTRY */
6799         ISP_FC_OPMAP(0x00, 0x00),       /* 0x4b: */
6800         ISP_FC_OPMAP(0x00, 0x00),       /* 0x4c: */
6801         ISP_FC_OPMAP(0x00, 0x00),       /* 0x4d: */
6802         ISP_FC_OPMAP(0x00, 0x00),       /* 0x4e: */
6803         ISP_FC_OPMAP(0x00, 0x00),       /* 0x4f: */
6804         ISP_FC_OPMAP(0x00, 0x00),       /* 0x50: */
6805         ISP_FC_OPMAP(0x00, 0x00),       /* 0x51: */
6806         ISP_FC_OPMAP(0x00, 0x00),       /* 0x52: */
6807         ISP_FC_OPMAP(0x00, 0x00),       /* 0x53: */
6808         ISP_FC_OPMAP(0xcf, 0x01),       /* 0x54: EXECUTE IOCB A64 */
6809         ISP_FC_OPMAP(0x00, 0x00),       /* 0x55: */
6810         ISP_FC_OPMAP(0x00, 0x00),       /* 0x56: */
6811         ISP_FC_OPMAP(0x00, 0x00),       /* 0x57: */
6812         ISP_FC_OPMAP(0x00, 0x00),       /* 0x58: */
6813         ISP_FC_OPMAP(0x00, 0x00),       /* 0x59: */
6814         ISP_FC_OPMAP(0x00, 0x00),       /* 0x5a: */
6815         ISP_FC_OPMAP(0x03, 0x01),       /* 0x5b: MBOX_DRIVER_HEARTBEAT */
6816         ISP_FC_OPMAP(0xcf, 0x01),       /* 0x5c: MBOX_FW_HEARTBEAT */
6817         ISP_FC_OPMAP(0x07, 0x1f),       /* 0x5d: MBOX_GET_SET_DATA_RATE */
6818         ISP_FC_OPMAP(0x00, 0x00),       /* 0x5e: */
6819         ISP_FC_OPMAP(0x00, 0x00),       /* 0x5f: */
6820         ISP_FC_OPMAP(0xcf, 0x0f),       /* 0x60: MBOX_INIT_FIRMWARE */
6821         ISP_FC_OPMAP(0x00, 0x00),       /* 0x61: */
6822         ISP_FC_OPMAP(0x01, 0x01),       /* 0x62: MBOX_INIT_LIP */
6823         ISP_FC_OPMAP(0xcd, 0x03),       /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
6824         ISP_FC_OPMAP(0xcf, 0x01),       /* 0x64: MBOX_GET_PORT_DB */
6825         ISP_FC_OPMAP(0x07, 0x01),       /* 0x65: MBOX_CLEAR_ACA */
6826         ISP_FC_OPMAP(0x07, 0x01),       /* 0x66: MBOX_TARGET_RESET */
6827         ISP_FC_OPMAP(0x07, 0x01),       /* 0x67: MBOX_CLEAR_TASK_SET */
6828         ISP_FC_OPMAP(0x07, 0x01),       /* 0x68: MBOX_ABORT_TASK_SET */
6829         ISP_FC_OPMAP(0x01, 0x07),       /* 0x69: MBOX_GET_FW_STATE */
6830         ISP_FC_OPMAP_HALF(0x6, 0x03, 0x0, 0xcf),        /* 0x6a: MBOX_GET_PORT_NAME */
6831         ISP_FC_OPMAP(0xcf, 0x01),       /* 0x6b: MBOX_GET_LINK_STATUS */
6832         ISP_FC_OPMAP(0x0f, 0x01),       /* 0x6c: MBOX_INIT_LIP_RESET */
6833         ISP_FC_OPMAP(0x00, 0x00),       /* 0x6d: */
6834         ISP_FC_OPMAP(0xcf, 0x03),       /* 0x6e: MBOX_SEND_SNS */
6835         ISP_FC_OPMAP(0x0f, 0x07),       /* 0x6f: MBOX_FABRIC_LOGIN */
6836         ISP_FC_OPMAP_HALF(0x02, 0x03, 0x00, 0x03),      /* 0x70: MBOX_SEND_CHANGE_REQUEST */
6837         ISP_FC_OPMAP(0x03, 0x03),       /* 0x71: MBOX_FABRIC_LOGOUT */
6838         ISP_FC_OPMAP(0x0f, 0x0f),       /* 0x72: MBOX_INIT_LIP_LOGIN */
6839         ISP_FC_OPMAP(0x00, 0x00),       /* 0x73: */
6840         ISP_FC_OPMAP(0x07, 0x01),       /* 0x74: LOGIN LOOP PORT */
6841         ISP_FC_OPMAP_HALF(0x03, 0xcf, 0x00, 0x07),      /* 0x75: GET PORT/NODE NAME LIST */
6842         ISP_FC_OPMAP(0x4f, 0x01),       /* 0x76: SET VENDOR ID */
6843         ISP_FC_OPMAP(0xcd, 0x01),       /* 0x77: INITIALIZE IP MAILBOX */
6844         ISP_FC_OPMAP(0x00, 0x00),       /* 0x78: */
6845         ISP_FC_OPMAP(0x00, 0x00),       /* 0x79: */
6846         ISP_FC_OPMAP(0x00, 0x00),       /* 0x7a: */
6847         ISP_FC_OPMAP(0x00, 0x00),       /* 0x7b: */
6848         ISP_FC_OPMAP_HALF(0x03, 0x4f, 0x00, 0x07),      /* 0x7c: Get ID List */
6849         ISP_FC_OPMAP(0xcf, 0x01),       /* 0x7d: SEND LFA */
6850         ISP_FC_OPMAP(0x0f, 0x01)        /* 0x7e: LUN RESET */
6851 };
6852 #define MAX_FC_OPCODE   0x7e
6853 /*
6854  * Footnotes
6855  *
6856  * (1): this sets bits 21..16 in mailbox register #8, which we nominally
6857  *      do not access at this time in the core driver. The caller is
6858  *      responsible for setting this register first (Gross!). The assumption
6859  *      is that we won't overflow.
6860  */
6861
6862 static const char *fc_mbcmd_names[] = {
6863         "NO-OP",                        /* 00h */
6864         "LOAD RAM",
6865         "EXEC FIRMWARE",
6866         "DUMP RAM",
6867         "WRITE RAM WORD",
6868         "READ RAM WORD",
6869         "MAILBOX REG TEST",
6870         "VERIFY CHECKSUM",
6871         "ABOUT FIRMWARE",
6872         "LOAD RAM (2100)",
6873         "DUMP RAM",
6874         "LOAD RISC RAM",
6875         "DUMP RISC RAM",
6876         "WRITE RAM WORD EXTENDED",
6877         "CHECK FIRMWARE",
6878         "READ RAM WORD EXTENDED",
6879         "INIT REQUEST QUEUE",           /* 10h */
6880         "INIT RESULT QUEUE",
6881         "EXECUTE IOCB",
6882         "WAKE UP",
6883         "STOP FIRMWARE",
6884         "ABORT",
6885         "ABORT DEVICE",
6886         "ABORT TARGET",
6887         "BUS RESET",
6888         "STOP QUEUE",
6889         "START QUEUE",
6890         "SINGLE STEP QUEUE",
6891         "ABORT QUEUE",
6892         "GET DEV QUEUE STATUS",
6893         NULL,
6894         "GET FIRMWARE STATUS",
6895         "GET LOOP ID",                  /* 20h */
6896         NULL,
6897         "GET TIMEOUT PARAMS",
6898         NULL,
6899         NULL,
6900         NULL,
6901         NULL,
6902         NULL,
6903         "GET FIRMWARE OPTIONS",
6904         "GET PORT QUEUE PARAMS",
6905         "GENERATE SYSTEM ERROR",
6906         NULL,
6907         NULL,
6908         NULL,
6909         NULL,
6910         NULL,
6911         "WRITE SFP",                    /* 30h */
6912         "READ SFP",
6913         "SET TIMEOUT PARAMS",
6914         NULL,
6915         NULL,
6916         NULL,
6917         NULL,
6918         NULL,
6919         "SET FIRMWARE OPTIONS",
6920         "SET PORT QUEUE PARAMS",
6921         NULL,
6922         "SET FC LED CONF",
6923         NULL,
6924         "RESTART NIC FIRMWARE",
6925         "ACCESS CONTROL",
6926         NULL,
6927         "LOOP PORT BYPASS",             /* 40h */
6928         "LOOP PORT ENABLE",
6929         "GET RESOURCE COUNT",
6930         "REQUEST NON PARTICIPATING MODE",
6931         "DIAGNOSTIC ECHO TEST",
6932         "DIAGNOSTIC LOOPBACK",
6933         NULL,
6934         "GET PORT DATABASE ENHANCED",
6935         "INIT FIRMWARE MULTI ID",
6936         "GET VP DATABASE",
6937         "GET VP DATABASE ENTRY",
6938         NULL,
6939         NULL,
6940         NULL,
6941         NULL,
6942         NULL,
6943         "GET FCF LIST",                 /* 50h */
6944         "GET DCBX PARAMETERS",
6945         NULL,
6946         "HOST MEMORY COPY",
6947         "EXECUTE IOCB A64",
6948         NULL,
6949         NULL,
6950         "SEND RNID",
6951         NULL,
6952         "SET PARAMETERS",
6953         "GET PARAMETERS",
6954         "DRIVER HEARTBEAT",
6955         "FIRMWARE HEARTBEAT",
6956         "GET/SET DATA RATE",
6957         "SEND RNFT",
6958         NULL,
6959         "INIT FIRMWARE",                /* 60h */
6960         "GET INIT CONTROL BLOCK",
6961         "INIT LIP",
6962         "GET FC-AL POSITION MAP",
6963         "GET PORT DATABASE",
6964         "CLEAR ACA",
6965         "TARGET RESET",
6966         "CLEAR TASK SET",
6967         "ABORT TASK SET",
6968         "GET FW STATE",
6969         "GET PORT NAME",
6970         "GET LINK STATUS",
6971         "INIT LIP RESET",
6972         "GET LINK STATS & PRIVATE DATA CNTS",
6973         "SEND SNS",
6974         "FABRIC LOGIN",
6975         "SEND CHANGE REQUEST",          /* 70h */
6976         "FABRIC LOGOUT",
6977         "INIT LIP LOGIN",
6978         NULL,
6979         "LOGIN LOOP PORT",
6980         "GET PORT/NODE NAME LIST",
6981         "SET VENDOR ID",
6982         "INITIALIZE IP MAILBOX",
6983         NULL,
6984         NULL,
6985         "GET XGMAC STATS",
6986         NULL,
6987         "GET ID LIST",
6988         "SEND LFA",
6989         "LUN RESET"
6990 };
6991
6992 static void
6993 isp_mboxcmd(ispsoftc_t *isp, mbreg_t *mbp)
6994 {
6995         const char *cname, *xname, *sname;
6996         char tname[16], mname[16];
6997         unsigned int ibits, obits, box, opcode;
6998
6999         opcode = mbp->param[0];
7000         if (IS_FC(isp)) {
7001                 if (opcode > MAX_FC_OPCODE) {
7002                         mbp->param[0] = MBOX_INVALID_COMMAND;
7003                         isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
7004                         return;
7005                 }
7006                 cname = fc_mbcmd_names[opcode];
7007                 ibits = ISP_FC_IBITS(opcode);
7008                 obits = ISP_FC_OBITS(opcode);
7009         } else {
7010                 if (opcode > MAX_SCSI_OPCODE) {
7011                         mbp->param[0] = MBOX_INVALID_COMMAND;
7012                         isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
7013                         return;
7014                 }
7015                 cname = scsi_mbcmd_names[opcode];
7016                 ibits = ISP_SCSI_IBITS(opcode);
7017                 obits = ISP_SCSI_OBITS(opcode);
7018         }
7019         if (cname == NULL) {
7020                 cname = tname;
7021                 ISP_SNPRINTF(tname, sizeof tname, "opcode %x", opcode);
7022         }
7023         isp_prt(isp, ISP_LOGDEBUG3, "Mailbox Command '%s'", cname);
7024
7025         /*
7026          * Pick up any additional bits that the caller might have set.
7027          */
7028         ibits |= mbp->ibits;
7029         obits |= mbp->obits;
7030
7031         /*
7032          * Mask any bits that the caller wants us to mask
7033          */
7034         ibits &= mbp->ibitm;
7035         obits &= mbp->obitm;
7036
7037
7038         if (ibits == 0 && obits == 0) {
7039                 mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
7040                 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
7041                 return;
7042         }
7043
7044         /*
7045          * Get exclusive usage of mailbox registers.
7046          */
7047         if (MBOX_ACQUIRE(isp)) {
7048                 mbp->param[0] = MBOX_REGS_BUSY;
7049                 goto out;
7050         }
7051
7052         for (box = 0; box < ISP_NMBOX(isp); box++) {
7053                 if (ibits & (1 << box)) {
7054                         isp_prt(isp, ISP_LOGDEBUG3, "IN mbox %d = 0x%04x", box,
7055                             mbp->param[box]);
7056                         ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
7057                 }
7058                 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
7059         }
7060
7061         isp->isp_lastmbxcmd = opcode;
7062
7063         /*
7064          * We assume that we can't overwrite a previous command.
7065          */
7066         isp->isp_obits = obits;
7067         isp->isp_mboxbsy = 1;
7068
7069         /*
7070          * Set Host Interrupt condition so that RISC will pick up mailbox regs.
7071          */
7072         if (IS_24XX(isp)) {
7073                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
7074         } else {
7075                 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
7076         }
7077
7078         /*
7079          * While we haven't finished the command, spin our wheels here.
7080          */
7081         MBOX_WAIT_COMPLETE(isp, mbp);
7082
7083         /*
7084          * Did the command time out?
7085          */
7086         if (mbp->param[0] == MBOX_TIMEOUT) {
7087                 isp->isp_mboxbsy = 0;
7088                 MBOX_RELEASE(isp);
7089                 goto out;
7090         }
7091
7092         /*
7093          * Copy back output registers.
7094          */
7095         for (box = 0; box < ISP_NMBOX(isp); box++) {
7096                 if (obits & (1 << box)) {
7097                         mbp->param[box] = isp->isp_mboxtmp[box];
7098                         isp_prt(isp, ISP_LOGDEBUG3, "OUT mbox %d = 0x%04x", box,
7099                             mbp->param[box]);
7100                 }
7101         }
7102
7103         isp->isp_mboxbsy = 0;
7104         MBOX_RELEASE(isp);
7105 out:
7106         if (mbp->logval == 0 || mbp->param[0] == MBOX_COMMAND_COMPLETE)
7107                 return;
7108
7109         if ((mbp->param[0] & 0xbfe0) == 0 &&
7110             (mbp->logval & MBLOGMASK(mbp->param[0])) == 0)
7111                 return;
7112
7113         xname = NULL;
7114         sname = "";
7115         switch (mbp->param[0]) {
7116         case MBOX_INVALID_COMMAND:
7117                 xname = "INVALID COMMAND";
7118                 break;
7119         case MBOX_HOST_INTERFACE_ERROR:
7120                 xname = "HOST INTERFACE ERROR";
7121                 break;
7122         case MBOX_TEST_FAILED:
7123                 xname = "TEST FAILED";
7124                 break;
7125         case MBOX_COMMAND_ERROR:
7126                 xname = "COMMAND ERROR";
7127                 ISP_SNPRINTF(mname, sizeof(mname), " subcode 0x%x",
7128                     mbp->param[1]);
7129                 sname = mname;
7130                 break;
7131         case MBOX_COMMAND_PARAM_ERROR:
7132                 xname = "COMMAND PARAMETER ERROR";
7133                 break;
7134         case MBOX_PORT_ID_USED:
7135                 xname = "PORT ID ALREADY IN USE";
7136                 break;
7137         case MBOX_LOOP_ID_USED:
7138                 xname = "LOOP ID ALREADY IN USE";
7139                 break;
7140         case MBOX_ALL_IDS_USED:
7141                 xname = "ALL LOOP IDS IN USE";
7142                 break;
7143         case MBOX_NOT_LOGGED_IN:
7144                 xname = "NOT LOGGED IN";
7145                 break;
7146         case MBOX_LINK_DOWN_ERROR:
7147                 xname = "LINK DOWN ERROR";
7148                 break;
7149         case MBOX_LOOPBACK_ERROR:
7150                 xname = "LOOPBACK ERROR";
7151                 break;
7152         case MBOX_CHECKSUM_ERROR:
7153                 xname = "CHECKSUM ERROR";
7154                 break;
7155         case MBOX_INVALID_PRODUCT_KEY:
7156                 xname = "INVALID PRODUCT KEY";
7157                 break;
7158         case MBOX_REGS_BUSY:
7159                 xname = "REGISTERS BUSY";
7160                 break;
7161         case MBOX_TIMEOUT:
7162                 xname = "TIMEOUT";
7163                 break;
7164         default:
7165                 ISP_SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
7166                 xname = mname;
7167                 break;
7168         }
7169         if (xname) {
7170                 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s%s)",
7171                     cname, xname, sname);
7172         }
7173 }
7174
7175 static int
7176 isp_fw_state(ispsoftc_t *isp, int chan)
7177 {
7178         if (IS_FC(isp)) {
7179                 mbreg_t mbs;
7180
7181                 MBSINIT(&mbs, MBOX_GET_FW_STATE, MBLOGALL, 0);
7182                 isp_mboxcmd(isp, &mbs);
7183                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
7184                         return (mbs.param[1]);
7185                 }
7186         }
7187         return (FW_ERROR);
7188 }
7189
7190 static void
7191 isp_spi_update(ispsoftc_t *isp, int chan)
7192 {
7193         int tgt;
7194         mbreg_t mbs;
7195         sdparam *sdp;
7196
7197         if (IS_FC(isp)) {
7198                 /*
7199                  * There are no 'per-bus' settings for Fibre Channel.
7200                  */
7201                 return;
7202         }
7203         sdp = SDPARAM(isp, chan);
7204         sdp->update = 0;
7205
7206         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7207                 uint16_t flags, period, offset;
7208                 int get;
7209
7210                 if (sdp->isp_devparam[tgt].dev_enable == 0) {
7211                         sdp->isp_devparam[tgt].dev_update = 0;
7212                         sdp->isp_devparam[tgt].dev_refresh = 0;
7213                         isp_prt(isp, ISP_LOGDEBUG0, "skipping target %d bus %d update", tgt, chan);
7214                         continue;
7215                 }
7216                 /*
7217                  * If the goal is to update the status of the device,
7218                  * take what's in goal_flags and try and set the device
7219                  * toward that. Otherwise, if we're just refreshing the
7220                  * current device state, get the current parameters.
7221                  */
7222
7223                 MBSINIT(&mbs, 0, MBLOGALL, 0);
7224
7225                 /*
7226                  * Refresh overrides set
7227                  */
7228                 if (sdp->isp_devparam[tgt].dev_refresh) {
7229                         mbs.param[0] = MBOX_GET_TARGET_PARAMS;
7230                         get = 1;
7231                 } else if (sdp->isp_devparam[tgt].dev_update) {
7232                         mbs.param[0] = MBOX_SET_TARGET_PARAMS;
7233
7234                         /*
7235                          * Make sure goal_flags has "Renegotiate on Error"
7236                          * on and "Freeze Queue on Error" off.
7237                          */
7238                         sdp->isp_devparam[tgt].goal_flags |= DPARM_RENEG;
7239                         sdp->isp_devparam[tgt].goal_flags &= ~DPARM_QFRZ;
7240                         mbs.param[2] = sdp->isp_devparam[tgt].goal_flags;
7241
7242                         /*
7243                          * Insist that PARITY must be enabled
7244                          * if SYNC or WIDE is enabled.
7245                          */
7246                         if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) {
7247                                 mbs.param[2] |= DPARM_PARITY;
7248                         }
7249
7250                         if (mbs.param[2] & DPARM_SYNC) {
7251                                 mbs.param[3] =
7252                                     (sdp->isp_devparam[tgt].goal_offset << 8) |
7253                                     (sdp->isp_devparam[tgt].goal_period);
7254                         }
7255                         /*
7256                          * A command completion later that has
7257                          * RQSTF_NEGOTIATION set can cause
7258                          * the dev_refresh/announce cycle also.
7259                          *
7260                          * Note: It is really important to update our current
7261                          * flags with at least the state of TAG capabilities-
7262                          * otherwise we might try and send a tagged command
7263                          * when we have it all turned off. So change it here
7264                          * to say that current already matches goal.
7265                          */
7266                         sdp->isp_devparam[tgt].actv_flags &= ~DPARM_TQING;
7267                         sdp->isp_devparam[tgt].actv_flags |=
7268                             (sdp->isp_devparam[tgt].goal_flags & DPARM_TQING);
7269                         isp_prt(isp, ISP_LOGDEBUG0, "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
7270                             chan, tgt, mbs.param[2], mbs.param[3] >> 8, mbs.param[3] & 0xff);
7271                         get = 0;
7272                 } else {
7273                         continue;
7274                 }
7275                 mbs.param[1] = (chan << 15) | (tgt << 8);
7276                 isp_mboxcmd(isp, &mbs);
7277                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
7278                         continue;
7279                 }
7280                 if (get == 0) {
7281                         sdp->sendmarker = 1;
7282                         sdp->isp_devparam[tgt].dev_update = 0;
7283                         sdp->isp_devparam[tgt].dev_refresh = 1;
7284                 } else {
7285                         sdp->isp_devparam[tgt].dev_refresh = 0;
7286                         flags = mbs.param[2];
7287                         period = mbs.param[3] & 0xff;
7288                         offset = mbs.param[3] >> 8;
7289                         sdp->isp_devparam[tgt].actv_flags = flags;
7290                         sdp->isp_devparam[tgt].actv_period = period;
7291                         sdp->isp_devparam[tgt].actv_offset = offset;
7292                         isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, chan, tgt);
7293                 }
7294         }
7295
7296         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7297                 if (sdp->isp_devparam[tgt].dev_update ||
7298                     sdp->isp_devparam[tgt].dev_refresh) {
7299                         sdp->update = 1;
7300                         break;
7301                 }
7302         }
7303 }
7304
7305 static void
7306 isp_setdfltsdparm(ispsoftc_t *isp)
7307 {
7308         int tgt;
7309         sdparam *sdp, *sdp1;
7310
7311         sdp = SDPARAM(isp, 0);
7312         if (IS_DUALBUS(isp))
7313                 sdp1 = sdp + 1;
7314         else
7315                 sdp1 = NULL;
7316
7317         /*
7318          * Establish some default parameters.
7319          */
7320         sdp->isp_cmd_dma_burst_enable = 0;
7321         sdp->isp_data_dma_burst_enabl = 1;
7322         sdp->isp_fifo_threshold = 0;
7323         sdp->isp_initiator_id = DEFAULT_IID(isp, 0);
7324         if (isp->isp_type >= ISP_HA_SCSI_1040) {
7325                 sdp->isp_async_data_setup = 9;
7326         } else {
7327                 sdp->isp_async_data_setup = 6;
7328         }
7329         sdp->isp_selection_timeout = 250;
7330         sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
7331         sdp->isp_tag_aging = 8;
7332         sdp->isp_bus_reset_delay = 5;
7333         /*
7334          * Don't retry selection, busy or queue full automatically- reflect
7335          * these back to us.
7336          */
7337         sdp->isp_retry_count = 0;
7338         sdp->isp_retry_delay = 0;
7339
7340         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7341                 sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE;
7342                 sdp->isp_devparam[tgt].dev_enable = 1;
7343         }
7344
7345         /*
7346          * The trick here is to establish a default for the default (honk!)
7347          * state (goal_flags). Then try and get the current status from
7348          * the card to fill in the current state. We don't, in fact, set
7349          * the default to the SAFE default state- that's not the goal state.
7350          */
7351         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7352                 uint8_t off, per;
7353                 sdp->isp_devparam[tgt].actv_offset = 0;
7354                 sdp->isp_devparam[tgt].actv_period = 0;
7355                 sdp->isp_devparam[tgt].actv_flags = 0;
7356
7357                 sdp->isp_devparam[tgt].goal_flags =
7358                     sdp->isp_devparam[tgt].nvrm_flags = DPARM_DEFAULT;
7359
7360                 /*
7361                  * We default to Wide/Fast for versions less than a 1040
7362                  * (unless it's SBus).
7363                  */
7364                 if (IS_ULTRA3(isp)) {
7365                         off = ISP_80M_SYNCPARMS >> 8;
7366                         per = ISP_80M_SYNCPARMS & 0xff;
7367                 } else if (IS_ULTRA2(isp)) {
7368                         off = ISP_40M_SYNCPARMS >> 8;
7369                         per = ISP_40M_SYNCPARMS & 0xff;
7370                 } else if (IS_1240(isp)) {
7371                         off = ISP_20M_SYNCPARMS >> 8;
7372                         per = ISP_20M_SYNCPARMS & 0xff;
7373                 } else if ((isp->isp_bustype == ISP_BT_SBUS &&
7374                     isp->isp_type < ISP_HA_SCSI_1020A) ||
7375                     (isp->isp_bustype == ISP_BT_PCI &&
7376                     isp->isp_type < ISP_HA_SCSI_1040) ||
7377                     (isp->isp_clock && isp->isp_clock < 60) ||
7378                     (sdp->isp_ultramode == 0)) {
7379                         off = ISP_10M_SYNCPARMS >> 8;
7380                         per = ISP_10M_SYNCPARMS & 0xff;
7381                 } else {
7382                         off = ISP_20M_SYNCPARMS_1040 >> 8;
7383                         per = ISP_20M_SYNCPARMS_1040 & 0xff;
7384                 }
7385                 sdp->isp_devparam[tgt].goal_offset =
7386                     sdp->isp_devparam[tgt].nvrm_offset = off;
7387                 sdp->isp_devparam[tgt].goal_period =
7388                     sdp->isp_devparam[tgt].nvrm_period = per;
7389
7390         }
7391
7392         /*
7393          * If we're a dual bus card, just copy the data over
7394          */
7395         if (sdp1) {
7396                 *sdp1 = *sdp;
7397                 sdp1->isp_initiator_id = DEFAULT_IID(isp, 1);
7398         }
7399
7400         /*
7401          * If we've not been told to avoid reading NVRAM, try and read it.
7402          * If we're successful reading it, we can then return because NVRAM
7403          * will tell us what the desired settings are. Otherwise, we establish
7404          * some reasonable 'fake' nvram and goal defaults.
7405          */
7406         if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7407                 mbreg_t mbs;
7408
7409                 if (isp_read_nvram(isp, 0) == 0) {
7410                         if (IS_DUALBUS(isp)) {
7411                                 if (isp_read_nvram(isp, 1) == 0) {
7412                                         return;
7413                                 }
7414                         }
7415                 }
7416                 MBSINIT(&mbs, MBOX_GET_ACT_NEG_STATE, MBLOGNONE, 0);
7417                 isp_mboxcmd(isp, &mbs);
7418                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
7419                         sdp->isp_req_ack_active_neg = 1;
7420                         sdp->isp_data_line_active_neg = 1;
7421                         if (sdp1) {
7422                                 sdp1->isp_req_ack_active_neg = 1;
7423                                 sdp1->isp_data_line_active_neg = 1;
7424                         }
7425                 } else {
7426                         sdp->isp_req_ack_active_neg =
7427                             (mbs.param[1] >> 4) & 0x1;
7428                         sdp->isp_data_line_active_neg =
7429                             (mbs.param[1] >> 5) & 0x1;
7430                         if (sdp1) {
7431                                 sdp1->isp_req_ack_active_neg =
7432                                     (mbs.param[2] >> 4) & 0x1;
7433                                 sdp1->isp_data_line_active_neg =
7434                                     (mbs.param[2] >> 5) & 0x1;
7435                         }
7436                 }
7437         }
7438
7439 }
7440
7441 static void
7442 isp_setdfltfcparm(ispsoftc_t *isp, int chan)
7443 {
7444         fcparam *fcp = FCPARAM(isp, chan);
7445
7446         /*
7447          * Establish some default parameters.
7448          */
7449         fcp->role = DEFAULT_ROLE(isp, chan);
7450         fcp->isp_maxalloc = ICB_DFLT_ALLOC;
7451         fcp->isp_retry_delay = ICB_DFLT_RDELAY;
7452         fcp->isp_retry_count = ICB_DFLT_RCOUNT;
7453         fcp->isp_loopid = DEFAULT_LOOPID(isp, chan);
7454         fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp, chan);
7455         fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp, chan);
7456         fcp->isp_fwoptions = 0;
7457         fcp->isp_xfwoptions = 0;
7458         fcp->isp_zfwoptions = 0;
7459         fcp->isp_lasthdl = NIL_HANDLE;
7460         fcp->isp_login_hdl = NIL_HANDLE;
7461
7462         if (IS_24XX(isp)) {
7463                 fcp->isp_fwoptions |= ICB2400_OPT1_FAIRNESS;
7464                 fcp->isp_fwoptions |= ICB2400_OPT1_HARD_ADDRESS;
7465                 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
7466                         fcp->isp_fwoptions |= ICB2400_OPT1_FULL_DUPLEX;
7467                 fcp->isp_fwoptions |= ICB2400_OPT1_BOTH_WWNS;
7468                 fcp->isp_xfwoptions |= ICB2400_OPT2_LOOP_2_PTP;
7469                 fcp->isp_zfwoptions |= ICB2400_OPT3_RATE_AUTO;
7470         } else {
7471                 fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
7472                 fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
7473                 fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
7474                 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
7475                         fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
7476                 /*
7477                  * Make sure this is turned off now until we get
7478                  * extended options from NVRAM
7479                  */
7480                 fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
7481                 fcp->isp_xfwoptions |= ICBXOPT_LOOP_2_PTP;
7482                 fcp->isp_zfwoptions |= ICBZOPT_RATE_AUTO;
7483         }
7484
7485
7486         /*
7487          * Now try and read NVRAM unless told to not do so.
7488          * This will set fcparam's isp_wwnn_nvram && isp_wwpn_nvram.
7489          */
7490         if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7491                 int i, j = 0;
7492                 /*
7493                  * Give a couple of tries at reading NVRAM.
7494                  */
7495                 for (i = 0; i < 2; i++) {
7496                         j = isp_read_nvram(isp, chan);
7497                         if (j == 0) {
7498                                 break;
7499                         }
7500                 }
7501                 if (j) {
7502                         isp->isp_confopts |= ISP_CFG_NONVRAM;
7503                 }
7504         }
7505
7506         fcp->isp_wwnn = ACTIVE_NODEWWN(isp, chan);
7507         fcp->isp_wwpn = ACTIVE_PORTWWN(isp, chan);
7508         isp_prt(isp, ISP_LOGCONFIG, "Chan %d 0x%08x%08x/0x%08x%08x Role %s",
7509             chan, (uint32_t) (fcp->isp_wwnn >> 32), (uint32_t) (fcp->isp_wwnn),
7510             (uint32_t) (fcp->isp_wwpn >> 32), (uint32_t) (fcp->isp_wwpn),
7511             isp_class3_roles[fcp->role]);
7512 }
7513
7514 /*
7515  * Re-initialize the ISP and complete all orphaned commands
7516  * with a 'botched' notice. The reset/init routines should
7517  * not disturb an already active list of commands.
7518  */
7519
7520 int
7521 isp_reinit(ispsoftc_t *isp, int do_load_defaults)
7522 {
7523         int i, res = 0;
7524
7525         if (isp->isp_state > ISP_RESETSTATE)
7526                 isp_stop(isp);
7527         if (isp->isp_state != ISP_RESETSTATE)
7528                 isp_reset(isp, do_load_defaults);
7529         if (isp->isp_state != ISP_RESETSTATE) {
7530                 res = EIO;
7531                 isp_prt(isp, ISP_LOGERR, "%s: cannot reset card", __func__);
7532                 goto cleanup;
7533         }
7534
7535         isp_init(isp);
7536         if (isp->isp_state > ISP_RESETSTATE &&
7537             isp->isp_state != ISP_RUNSTATE) {
7538                 res = EIO;
7539                 isp_prt(isp, ISP_LOGERR, "%s: cannot init card", __func__);
7540                 ISP_DISABLE_INTS(isp);
7541                 if (IS_FC(isp)) {
7542                         /*
7543                          * If we're in ISP_ROLE_NONE, turn off the lasers.
7544                          */
7545                         if (!IS_24XX(isp)) {
7546                                 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
7547                                 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
7548                                 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
7549                                 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
7550                                 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
7551                         }
7552                 }
7553         }
7554
7555 cleanup:
7556         isp_clear_commands(isp);
7557         if (IS_FC(isp)) {
7558                 for (i = 0; i < isp->isp_nchan; i++)
7559                         isp_clear_portdb(isp, i);
7560         }
7561         return (res);
7562 }
7563
7564 /*
7565  * NVRAM Routines
7566  */
7567 static int
7568 isp_read_nvram(ispsoftc_t *isp, int bus)
7569 {
7570         int i, amt, retval;
7571         uint8_t csum, minversion;
7572         union {
7573                 uint8_t _x[ISP2400_NVRAM_SIZE];
7574                 uint16_t _s[ISP2400_NVRAM_SIZE>>1];
7575         } _n;
7576 #define nvram_data      _n._x
7577 #define nvram_words     _n._s
7578
7579         if (IS_24XX(isp)) {
7580                 return (isp_read_nvram_2400(isp, nvram_data));
7581         } else if (IS_FC(isp)) {
7582                 amt = ISP2100_NVRAM_SIZE;
7583                 minversion = 1;
7584         } else if (IS_ULTRA2(isp)) {
7585                 amt = ISP1080_NVRAM_SIZE;
7586                 minversion = 0;
7587         } else {
7588                 amt = ISP_NVRAM_SIZE;
7589                 minversion = 2;
7590         }
7591
7592         for (i = 0; i < amt>>1; i++) {
7593                 isp_rdnvram_word(isp, i, &nvram_words[i]);
7594         }
7595
7596         if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7597             nvram_data[2] != 'P') {
7598                 if (isp->isp_bustype != ISP_BT_SBUS) {
7599                         isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
7600                         isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x", nvram_data[0], nvram_data[1], nvram_data[2]);
7601                 }
7602                 retval = -1;
7603                 goto out;
7604         }
7605
7606         for (csum = 0, i = 0; i < amt; i++) {
7607                 csum += nvram_data[i];
7608         }
7609         if (csum != 0) {
7610                 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7611                 retval = -1;
7612                 goto out;
7613         }
7614
7615         if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
7616                 isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
7617                     ISP_NVRAM_VERSION(nvram_data));
7618                 retval = -1;
7619                 goto out;
7620         }
7621
7622         if (IS_ULTRA3(isp)) {
7623                 isp_parse_nvram_12160(isp, bus, nvram_data);
7624         } else if (IS_1080(isp)) {
7625                 isp_parse_nvram_1080(isp, bus, nvram_data);
7626         } else if (IS_1280(isp) || IS_1240(isp)) {
7627                 isp_parse_nvram_1080(isp, bus, nvram_data);
7628         } else if (IS_SCSI(isp)) {
7629                 isp_parse_nvram_1020(isp, nvram_data);
7630         } else {
7631                 isp_parse_nvram_2100(isp, nvram_data);
7632         }
7633         retval = 0;
7634 out:
7635         return (retval);
7636 #undef  nvram_data
7637 #undef  nvram_words
7638 }
7639
7640 static int
7641 isp_read_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
7642 {
7643         int retval = 0;
7644         uint32_t addr, csum, lwrds, *dptr;
7645
7646         if (isp->isp_port) {
7647                 addr = ISP2400_NVRAM_PORT1_ADDR;
7648         } else {
7649                 addr = ISP2400_NVRAM_PORT0_ADDR;
7650         }
7651
7652         dptr = (uint32_t *) nvram_data;
7653         for (lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7654                 isp_rd_2400_nvram(isp, addr++, dptr++);
7655         }
7656         if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7657             nvram_data[2] != 'P') {
7658                 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header (%x %x %x)",
7659                     nvram_data[0], nvram_data[1], nvram_data[2]);
7660                 retval = -1;
7661                 goto out;
7662         }
7663         dptr = (uint32_t *) nvram_data;
7664         for (csum = 0, lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7665                 uint32_t tmp;
7666                 ISP_IOXGET_32(isp, &dptr[lwrds], tmp);
7667                 csum += tmp;
7668         }
7669         if (csum != 0) {
7670                 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7671                 retval = -1;
7672                 goto out;
7673         }
7674         isp_parse_nvram_2400(isp, nvram_data);
7675 out:
7676         return (retval);
7677 }
7678
7679 static void
7680 isp_rdnvram_word(ispsoftc_t *isp, int wo, uint16_t *rp)
7681 {
7682         int i, cbits;
7683         uint16_t bit, rqst, junk;
7684
7685         ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7686         ISP_DELAY(10);
7687         ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7688         ISP_DELAY(10);
7689
7690         if (IS_FC(isp)) {
7691                 wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
7692                 if (IS_2312(isp) && isp->isp_port) {
7693                         wo += 128;
7694                 }
7695                 rqst = (ISP_NVRAM_READ << 8) | wo;
7696                 cbits = 10;
7697         } else if (IS_ULTRA2(isp)) {
7698                 wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1);
7699                 rqst = (ISP_NVRAM_READ << 8) | wo;
7700                 cbits = 10;
7701         } else {
7702                 wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
7703                 rqst = (ISP_NVRAM_READ << 6) | wo;
7704                 cbits = 8;
7705         }
7706
7707         /*
7708          * Clock the word select request out...
7709          */
7710         for (i = cbits; i >= 0; i--) {
7711                 if ((rqst >> i) & 1) {
7712                         bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
7713                 } else {
7714                         bit = BIU_NVRAM_SELECT;
7715                 }
7716                 ISP_WRITE(isp, BIU_NVRAM, bit);
7717                 ISP_DELAY(10);
7718                 junk = ISP_READ(isp, BIU_NVRAM);        /* force PCI flush */
7719                 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
7720                 ISP_DELAY(10);
7721                 junk = ISP_READ(isp, BIU_NVRAM);        /* force PCI flush */
7722                 ISP_WRITE(isp, BIU_NVRAM, bit);
7723                 ISP_DELAY(10);
7724                 junk = ISP_READ(isp, BIU_NVRAM);        /* force PCI flush */
7725         }
7726         /*
7727          * Now read the result back in (bits come back in MSB format).
7728          */
7729         *rp = 0;
7730         for (i = 0; i < 16; i++) {
7731                 uint16_t rv;
7732                 *rp <<= 1;
7733                 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7734                 ISP_DELAY(10);
7735                 rv = ISP_READ(isp, BIU_NVRAM);
7736                 if (rv & BIU_NVRAM_DATAIN) {
7737                         *rp |= 1;
7738                 }
7739                 ISP_DELAY(10);
7740                 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7741                 ISP_DELAY(10);
7742                 junk = ISP_READ(isp, BIU_NVRAM);        /* force PCI flush */
7743         }
7744         ISP_WRITE(isp, BIU_NVRAM, 0);
7745         ISP_DELAY(10);
7746         junk = ISP_READ(isp, BIU_NVRAM);        /* force PCI flush */
7747         ISP_SWIZZLE_NVRAM_WORD(isp, rp);
7748 }
7749
7750 static void
7751 isp_rd_2400_nvram(ispsoftc_t *isp, uint32_t addr, uint32_t *rp)
7752 {
7753         int loops = 0;
7754         uint32_t base = 0x7ffe0000;
7755         uint32_t tmp = 0;
7756
7757         if (IS_26XX(isp)) {
7758                 base = 0x7fe7c000;      /* XXX: Observation, may be wrong. */
7759         } else if (IS_25XX(isp)) {
7760                 base = 0x7ff00000 | 0x48000;
7761         }
7762         ISP_WRITE(isp, BIU2400_FLASH_ADDR, base | addr);
7763         for (loops = 0; loops < 5000; loops++) {
7764                 ISP_DELAY(10);
7765                 tmp = ISP_READ(isp, BIU2400_FLASH_ADDR);
7766                 if ((tmp & (1U << 31)) != 0) {
7767                         break;
7768                 }
7769         }
7770         if (tmp & (1U << 31)) {
7771                 *rp = ISP_READ(isp, BIU2400_FLASH_DATA);
7772                 ISP_SWIZZLE_NVRAM_LONG(isp, rp);
7773         } else {
7774                 *rp = 0xffffffff;
7775         }
7776 }
7777
7778 static void
7779 isp_parse_nvram_1020(ispsoftc_t *isp, uint8_t *nvram_data)
7780 {
7781         sdparam *sdp = SDPARAM(isp, 0);
7782         int tgt;
7783
7784         sdp->isp_fifo_threshold =
7785                 ISP_NVRAM_FIFO_THRESHOLD(nvram_data) |
7786                 (ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2);
7787
7788         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7789                 sdp->isp_initiator_id = ISP_NVRAM_INITIATOR_ID(nvram_data);
7790
7791         sdp->isp_bus_reset_delay =
7792                 ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
7793
7794         sdp->isp_retry_count =
7795                 ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
7796
7797         sdp->isp_retry_delay =
7798                 ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
7799
7800         sdp->isp_async_data_setup =
7801                 ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
7802
7803         if (isp->isp_type >= ISP_HA_SCSI_1040) {
7804                 if (sdp->isp_async_data_setup < 9) {
7805                         sdp->isp_async_data_setup = 9;
7806                 }
7807         } else {
7808                 if (sdp->isp_async_data_setup != 6) {
7809                         sdp->isp_async_data_setup = 6;
7810                 }
7811         }
7812
7813         sdp->isp_req_ack_active_neg =
7814                 ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
7815
7816         sdp->isp_data_line_active_neg =
7817                 ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
7818
7819         sdp->isp_data_dma_burst_enabl =
7820                 ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
7821
7822         sdp->isp_cmd_dma_burst_enable =
7823                 ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
7824
7825         sdp->isp_tag_aging =
7826                 ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
7827
7828         sdp->isp_selection_timeout =
7829                 ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
7830
7831         sdp->isp_max_queue_depth =
7832                 ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
7833
7834         sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
7835
7836         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7837                 sdp->isp_devparam[tgt].dev_enable =
7838                         ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt);
7839                 sdp->isp_devparam[tgt].exc_throttle =
7840                         ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt);
7841                 sdp->isp_devparam[tgt].nvrm_offset =
7842                         ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt);
7843                 sdp->isp_devparam[tgt].nvrm_period =
7844                         ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt);
7845                 /*
7846                  * We probably shouldn't lie about this, but it
7847                  * it makes it much safer if we limit NVRAM values
7848                  * to sanity.
7849                  */
7850                 if (isp->isp_type < ISP_HA_SCSI_1040) {
7851                         /*
7852                          * If we're not ultra, we can't possibly
7853                          * be a shorter period than this.
7854                          */
7855                         if (sdp->isp_devparam[tgt].nvrm_period < 0x19) {
7856                                 sdp->isp_devparam[tgt].nvrm_period = 0x19;
7857                         }
7858                         if (sdp->isp_devparam[tgt].nvrm_offset > 0xc) {
7859                                 sdp->isp_devparam[tgt].nvrm_offset = 0x0c;
7860                         }
7861                 } else {
7862                         if (sdp->isp_devparam[tgt].nvrm_offset > 0x8) {
7863                                 sdp->isp_devparam[tgt].nvrm_offset = 0x8;
7864                         }
7865                 }
7866                 sdp->isp_devparam[tgt].nvrm_flags = 0;
7867                 if (ISP_NVRAM_TGT_RENEG(nvram_data, tgt))
7868                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7869                 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7870                 if (ISP_NVRAM_TGT_TQING(nvram_data, tgt))
7871                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7872                 if (ISP_NVRAM_TGT_SYNC(nvram_data, tgt))
7873                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7874                 if (ISP_NVRAM_TGT_WIDE(nvram_data, tgt))
7875                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7876                 if (ISP_NVRAM_TGT_PARITY(nvram_data, tgt))
7877                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7878                 if (ISP_NVRAM_TGT_DISC(nvram_data, tgt))
7879                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7880                 sdp->isp_devparam[tgt].actv_flags = 0; /* we don't know */
7881                 sdp->isp_devparam[tgt].goal_offset =
7882                     sdp->isp_devparam[tgt].nvrm_offset;
7883                 sdp->isp_devparam[tgt].goal_period =
7884                     sdp->isp_devparam[tgt].nvrm_period;
7885                 sdp->isp_devparam[tgt].goal_flags =
7886                     sdp->isp_devparam[tgt].nvrm_flags;
7887         }
7888 }
7889
7890 static void
7891 isp_parse_nvram_1080(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7892 {
7893         sdparam *sdp = SDPARAM(isp, bus);
7894         int tgt;
7895
7896         sdp->isp_fifo_threshold =
7897             ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data);
7898
7899         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7900                 sdp->isp_initiator_id = ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus);
7901
7902         sdp->isp_bus_reset_delay =
7903             ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7904
7905         sdp->isp_retry_count =
7906             ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7907
7908         sdp->isp_retry_delay =
7909             ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7910
7911         sdp->isp_async_data_setup =
7912             ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7913
7914         sdp->isp_req_ack_active_neg =
7915             ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7916
7917         sdp->isp_data_line_active_neg =
7918             ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7919
7920         sdp->isp_data_dma_burst_enabl =
7921             ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7922
7923         sdp->isp_cmd_dma_burst_enable =
7924             ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7925
7926         sdp->isp_selection_timeout =
7927             ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
7928
7929         sdp->isp_max_queue_depth =
7930              ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
7931
7932         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7933                 sdp->isp_devparam[tgt].dev_enable =
7934                     ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
7935                 sdp->isp_devparam[tgt].exc_throttle =
7936                         ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
7937                 sdp->isp_devparam[tgt].nvrm_offset =
7938                         ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
7939                 sdp->isp_devparam[tgt].nvrm_period =
7940                         ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
7941                 sdp->isp_devparam[tgt].nvrm_flags = 0;
7942                 if (ISP1080_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
7943                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7944                 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7945                 if (ISP1080_NVRAM_TGT_TQING(nvram_data, tgt, bus))
7946                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7947                 if (ISP1080_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
7948                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7949                 if (ISP1080_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
7950                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7951                 if (ISP1080_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
7952                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7953                 if (ISP1080_NVRAM_TGT_DISC(nvram_data, tgt, bus))
7954                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7955                 sdp->isp_devparam[tgt].actv_flags = 0;
7956                 sdp->isp_devparam[tgt].goal_offset =
7957                     sdp->isp_devparam[tgt].nvrm_offset;
7958                 sdp->isp_devparam[tgt].goal_period =
7959                     sdp->isp_devparam[tgt].nvrm_period;
7960                 sdp->isp_devparam[tgt].goal_flags =
7961                     sdp->isp_devparam[tgt].nvrm_flags;
7962         }
7963 }
7964
7965 static void
7966 isp_parse_nvram_12160(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7967 {
7968         sdparam *sdp = SDPARAM(isp, bus);
7969         int tgt;
7970
7971         sdp->isp_fifo_threshold =
7972             ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data);
7973
7974         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7975                 sdp->isp_initiator_id = ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus);
7976
7977         sdp->isp_bus_reset_delay =
7978             ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7979
7980         sdp->isp_retry_count =
7981             ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7982
7983         sdp->isp_retry_delay =
7984             ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7985
7986         sdp->isp_async_data_setup =
7987             ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7988
7989         sdp->isp_req_ack_active_neg =
7990             ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7991
7992         sdp->isp_data_line_active_neg =
7993             ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7994
7995         sdp->isp_data_dma_burst_enabl =
7996             ISP12160_NVRAM_BURST_ENABLE(nvram_data);
7997
7998         sdp->isp_cmd_dma_burst_enable =
7999             ISP12160_NVRAM_BURST_ENABLE(nvram_data);
8000
8001         sdp->isp_selection_timeout =
8002             ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
8003
8004         sdp->isp_max_queue_depth =
8005              ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
8006
8007         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
8008                 sdp->isp_devparam[tgt].dev_enable =
8009                     ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
8010                 sdp->isp_devparam[tgt].exc_throttle =
8011                         ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
8012                 sdp->isp_devparam[tgt].nvrm_offset =
8013                         ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
8014                 sdp->isp_devparam[tgt].nvrm_period =
8015                         ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
8016                 sdp->isp_devparam[tgt].nvrm_flags = 0;
8017                 if (ISP12160_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
8018                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
8019                 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
8020                 if (ISP12160_NVRAM_TGT_TQING(nvram_data, tgt, bus))
8021                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
8022                 if (ISP12160_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
8023                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
8024                 if (ISP12160_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
8025                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
8026                 if (ISP12160_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
8027                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
8028                 if (ISP12160_NVRAM_TGT_DISC(nvram_data, tgt, bus))
8029                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
8030                 sdp->isp_devparam[tgt].actv_flags = 0;
8031                 sdp->isp_devparam[tgt].goal_offset =
8032                     sdp->isp_devparam[tgt].nvrm_offset;
8033                 sdp->isp_devparam[tgt].goal_period =
8034                     sdp->isp_devparam[tgt].nvrm_period;
8035                 sdp->isp_devparam[tgt].goal_flags =
8036                     sdp->isp_devparam[tgt].nvrm_flags;
8037         }
8038 }
8039
8040 static void
8041 isp_parse_nvram_2100(ispsoftc_t *isp, uint8_t *nvram_data)
8042 {
8043         fcparam *fcp = FCPARAM(isp, 0);
8044         uint64_t wwn;
8045
8046         /*
8047          * There is NVRAM storage for both Port and Node entities-
8048          * but the Node entity appears to be unused on all the cards
8049          * I can find. However, we should account for this being set
8050          * at some point in the future.
8051          *
8052          * Qlogic WWNs have an NAA of 2, but usually nothing shows up in
8053          * bits 48..60. In the case of the 2202, it appears that they do
8054          * use bit 48 to distinguish between the two instances on the card.
8055          * The 2204, which I've never seen, *probably* extends this method.
8056          */
8057         wwn = ISP2100_NVRAM_PORT_NAME(nvram_data);
8058         if (wwn) {
8059                 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
8060                     (uint32_t) (wwn >> 32), (uint32_t) (wwn));
8061                 if ((wwn >> 60) == 0) {
8062                         wwn |= (((uint64_t) 2)<< 60);
8063                 }
8064         }
8065         fcp->isp_wwpn_nvram = wwn;
8066         if (IS_2200(isp) || IS_23XX(isp)) {
8067                 wwn = ISP2100_NVRAM_NODE_NAME(nvram_data);
8068                 if (wwn) {
8069                         isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
8070                             (uint32_t) (wwn >> 32),
8071                             (uint32_t) (wwn));
8072                         if ((wwn >> 60) == 0) {
8073                                 wwn |= (((uint64_t) 2)<< 60);
8074                         }
8075                 } else {
8076                         wwn = fcp->isp_wwpn_nvram & ~((uint64_t) 0xfff << 48);
8077                 }
8078         } else {
8079                 wwn &= ~((uint64_t) 0xfff << 48);
8080         }
8081         fcp->isp_wwnn_nvram = wwn;
8082
8083         fcp->isp_maxalloc = ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
8084         if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8085                 DEFAULT_FRAMESIZE(isp) =
8086                     ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
8087         }
8088         fcp->isp_retry_delay = ISP2100_NVRAM_RETRY_DELAY(nvram_data);
8089         fcp->isp_retry_count = ISP2100_NVRAM_RETRY_COUNT(nvram_data);
8090         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8091                 fcp->isp_loopid = ISP2100_NVRAM_HARDLOOPID(nvram_data);
8092         }
8093         if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8094                 DEFAULT_EXEC_THROTTLE(isp) =
8095                         ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
8096         }
8097         fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
8098         isp_prt(isp, ISP_LOGDEBUG0,
8099             "NVRAM 0x%08x%08x 0x%08x%08x maxalloc %d maxframelen %d",
8100             (uint32_t) (fcp->isp_wwnn_nvram >> 32),
8101             (uint32_t) fcp->isp_wwnn_nvram,
8102             (uint32_t) (fcp->isp_wwpn_nvram >> 32),
8103             (uint32_t) fcp->isp_wwpn_nvram,
8104             ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data),
8105             ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data));
8106         isp_prt(isp, ISP_LOGDEBUG0,
8107             "execthrottle %d fwoptions 0x%x hardloop %d tov %d",
8108             ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data),
8109             ISP2100_NVRAM_OPTIONS(nvram_data),
8110             ISP2100_NVRAM_HARDLOOPID(nvram_data),
8111             ISP2100_NVRAM_TOV(nvram_data));
8112         fcp->isp_xfwoptions = ISP2100_XFW_OPTIONS(nvram_data);
8113         fcp->isp_zfwoptions = ISP2100_ZFW_OPTIONS(nvram_data);
8114         isp_prt(isp, ISP_LOGDEBUG0, "xfwoptions 0x%x zfw options 0x%x",
8115             ISP2100_XFW_OPTIONS(nvram_data), ISP2100_ZFW_OPTIONS(nvram_data));
8116 }
8117
8118 static void
8119 isp_parse_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
8120 {
8121         fcparam *fcp = FCPARAM(isp, 0);
8122         uint64_t wwn;
8123
8124         isp_prt(isp, ISP_LOGDEBUG0,
8125             "NVRAM 0x%08x%08x 0x%08x%08x exchg_cnt %d maxframelen %d",
8126             (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data) >> 32),
8127             (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data)),
8128             (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data) >> 32),
8129             (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data)),
8130             ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data),
8131             ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data));
8132         isp_prt(isp, ISP_LOGDEBUG0,
8133             "NVRAM execthr %d loopid %d fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
8134             ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data),
8135             ISP2400_NVRAM_HARDLOOPID(nvram_data),
8136             ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data),
8137             ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data),
8138             ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data));
8139
8140         wwn = ISP2400_NVRAM_PORT_NAME(nvram_data);
8141         fcp->isp_wwpn_nvram = wwn;
8142
8143         wwn = ISP2400_NVRAM_NODE_NAME(nvram_data);
8144         if (wwn) {
8145                 if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
8146                         wwn = 0;
8147                 }
8148         }
8149         if (wwn == 0 && (fcp->isp_wwpn_nvram >> 60) == 2) {
8150                 wwn = fcp->isp_wwpn_nvram;
8151                 wwn &= ~((uint64_t) 0xfff << 48);
8152         }
8153         fcp->isp_wwnn_nvram = wwn;
8154
8155         if (ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data)) {
8156                 fcp->isp_maxalloc = ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data);
8157         }
8158         if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8159                 DEFAULT_FRAMESIZE(isp) =
8160                     ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data);
8161         }
8162         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8163                 fcp->isp_loopid = ISP2400_NVRAM_HARDLOOPID(nvram_data);
8164         }
8165         if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8166                 DEFAULT_EXEC_THROTTLE(isp) =
8167                         ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data);
8168         }
8169         fcp->isp_fwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data);
8170         fcp->isp_xfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data);
8171         fcp->isp_zfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data);
8172 }