Home | History | Annotate | Line # | Download | only in ic
isp_netbsd.c revision 1.27
      1  1.27   mjacob /* $NetBSD: isp_netbsd.c,v 1.27 2000/07/07 03:14:53 mjacob Exp $ */
      2   1.1   mjacob /*
      3   1.1   mjacob  * Platform (NetBSD) dependent common attachment code for Qlogic adapters.
      4  1.15   mjacob  * Matthew Jacob <mjacob (at) nas.nasa.gov>
      5  1.15   mjacob  */
      6  1.15   mjacob /*
      7  1.15   mjacob  * Copyright (C) 1997, 1998, 1999 National Aeronautics & Space Administration
      8   1.1   mjacob  * All rights reserved.
      9   1.1   mjacob  *
     10   1.1   mjacob  * Redistribution and use in source and binary forms, with or without
     11   1.1   mjacob  * modification, are permitted provided that the following conditions
     12   1.1   mjacob  * are met:
     13   1.1   mjacob  * 1. Redistributions of source code must retain the above copyright
     14  1.15   mjacob  *    notice, this list of conditions and the following disclaimer.
     15   1.1   mjacob  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.1   mjacob  *    notice, this list of conditions and the following disclaimer in the
     17   1.1   mjacob  *    documentation and/or other materials provided with the distribution.
     18   1.1   mjacob  * 3. The name of the author may not be used to endorse or promote products
     19  1.15   mjacob  *    derived from this software without specific prior written permission
     20   1.1   mjacob  *
     21  1.15   mjacob  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     22  1.15   mjacob  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     23  1.15   mjacob  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     24  1.15   mjacob  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     25  1.15   mjacob  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     26  1.15   mjacob  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     27  1.15   mjacob  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     28  1.15   mjacob  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     29  1.15   mjacob  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     30  1.15   mjacob  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     31   1.1   mjacob  */
     32   1.1   mjacob 
     33   1.1   mjacob #include <dev/ic/isp_netbsd.h>
     34  1.17   mjacob #include <sys/scsiio.h>
     35   1.1   mjacob 
     36  1.27   mjacob 
     37  1.27   mjacob /*
     38  1.27   mjacob  * Set a timeout for the watchdogging of a command.
     39  1.27   mjacob  *
     40  1.27   mjacob  * The dimensional analysis is
     41  1.27   mjacob  *
     42  1.27   mjacob  *	milliseconds * (seconds/millisecond) * (ticks/second) = ticks
     43  1.27   mjacob  *
     44  1.27   mjacob  *			=
     45  1.27   mjacob  *
     46  1.27   mjacob  *	(milliseconds / 1000) * hz = ticks
     47  1.27   mjacob  *
     48  1.27   mjacob  *
     49  1.27   mjacob  * For timeouts less than 1 second, we'll get zero. Because of this, and
     50  1.27   mjacob  * because we want to establish *our* timeout to be longer than what the
     51  1.27   mjacob  * firmware might do, we just add 3 seconds at the back end.
     52  1.27   mjacob  */
     53  1.27   mjacob #define	_XT(xs)	((((xs)->timeout/1000) * hz) + (3 * hz))
     54  1.26   mjacob 
     55   1.1   mjacob static void ispminphys __P((struct buf *));
     56  1.17   mjacob static int32_t ispcmd_slow __P((ISP_SCSI_XFER_T *));
     57   1.1   mjacob static int32_t ispcmd __P((ISP_SCSI_XFER_T *));
     58  1.17   mjacob static int
     59  1.17   mjacob ispioctl __P((struct scsipi_link *, u_long, caddr_t, int, struct proc *));
     60   1.1   mjacob 
     61   1.1   mjacob static struct scsipi_device isp_dev = { NULL, NULL, NULL, NULL };
     62  1.26   mjacob static int isp_polled_cmd __P((struct ispsoftc *, ISP_SCSI_XFER_T *));
     63  1.26   mjacob static void isp_dog __P((void *));
     64  1.17   mjacob static void isp_command_requeue __P((void *));
     65  1.10   mjacob static void isp_internal_restart __P((void *));
     66  1.10   mjacob 
     67   1.1   mjacob /*
     68   1.1   mjacob  * Complete attachment of hardware, include subdevices.
     69   1.1   mjacob  */
     70   1.1   mjacob void
     71   1.1   mjacob isp_attach(isp)
     72   1.1   mjacob 	struct ispsoftc *isp;
     73   1.1   mjacob {
     74  1.26   mjacob 	int maxluns = isp->isp_maxluns - 1;
     75   1.6  thorpej 
     76   1.6  thorpej 	isp->isp_osinfo._adapter.scsipi_minphys = ispminphys;
     77  1.17   mjacob 	isp->isp_osinfo._adapter.scsipi_ioctl = ispioctl;
     78   1.6  thorpej 
     79   1.1   mjacob 	isp->isp_state = ISP_RUNSTATE;
     80  1.21   mjacob 	isp->isp_osinfo._link.scsipi_scsi.channel =
     81  1.21   mjacob 	    (IS_DUALBUS(isp))? 0 : SCSI_CHANNEL_ONLY_ONE;
     82   1.1   mjacob 	isp->isp_osinfo._link.adapter_softc = isp;
     83   1.1   mjacob 	isp->isp_osinfo._link.device = &isp_dev;
     84   1.6  thorpej 	isp->isp_osinfo._link.adapter = &isp->isp_osinfo._adapter;
     85  1.17   mjacob 	isp->isp_osinfo._link.openings = isp->isp_maxcmds;
     86  1.26   mjacob 	isp->isp_osinfo._link.scsipi_scsi.max_lun = maxluns;
     87  1.18   mjacob 	TAILQ_INIT(&isp->isp_osinfo.waitq);	/* XXX 2nd Bus? */
     88   1.1   mjacob 
     89  1.15   mjacob 	if (IS_FC(isp)) {
     90  1.11   mjacob 		/*
     91  1.11   mjacob 		 * Give it another chance here to come alive...
     92  1.11   mjacob 		 */
     93  1.17   mjacob 		isp->isp_osinfo._adapter.scsipi_cmd = ispcmd;
     94   1.1   mjacob 		isp->isp_osinfo._link.scsipi_scsi.max_target = MAX_FC_TARG-1;
     95   1.7   mjacob 		/*
     96  1.26   mjacob 		 * But we have to be reasonable until the midlayer is fixed.
     97   1.7   mjacob 		 */
     98  1.26   mjacob 		if (maxluns > 255)
     99  1.26   mjacob 			isp->isp_osinfo._link.scsipi_scsi.max_lun = 255;
    100   1.1   mjacob 	} else {
    101  1.14   mjacob 		sdparam *sdp = isp->isp_param;
    102  1.17   mjacob 		isp->isp_osinfo._adapter.scsipi_cmd = ispcmd_slow;
    103   1.1   mjacob 		isp->isp_osinfo._link.scsipi_scsi.max_target = MAX_TARGETS-1;
    104   1.1   mjacob 		isp->isp_osinfo._link.scsipi_scsi.adapter_target =
    105  1.14   mjacob 		    sdp->isp_initiator_id;
    106  1.17   mjacob 		isp->isp_osinfo.discovered[0] = 1 << sdp->isp_initiator_id;
    107  1.26   mjacob 		/*
    108  1.26   mjacob 		 * But we have to be reasonable until the midlayer is fixed.
    109  1.26   mjacob 		 */
    110  1.26   mjacob 		if (maxluns > 7)
    111  1.26   mjacob 			isp->isp_osinfo._link.scsipi_scsi.max_lun = 7;
    112  1.21   mjacob 		if (IS_DUALBUS(isp)) {
    113  1.14   mjacob 			isp->isp_osinfo._link_b = isp->isp_osinfo._link;
    114  1.14   mjacob 			sdp++;
    115  1.18   mjacob 			isp->isp_osinfo.discovered[1] =
    116  1.18   mjacob 			    1 << sdp->isp_initiator_id;
    117  1.14   mjacob 			isp->isp_osinfo._link_b.scsipi_scsi.adapter_target =
    118  1.14   mjacob 			    sdp->isp_initiator_id;
    119  1.14   mjacob 			isp->isp_osinfo._link_b.scsipi_scsi.channel = 1;
    120  1.26   mjacob 			isp->isp_osinfo._link_b.scsipi_scsi.max_lun =
    121  1.26   mjacob 			    isp->isp_osinfo._link.scsipi_scsi.max_lun;
    122  1.14   mjacob 		}
    123   1.1   mjacob 	}
    124   1.1   mjacob 	isp->isp_osinfo._link.type = BUS_SCSI;
    125   1.8   mjacob 
    126   1.8   mjacob 	/*
    127  1.25       he 	 * Send a SCSI Bus Reset.
    128  1.10   mjacob 	 */
    129  1.14   mjacob 	if (IS_SCSI(isp)) {
    130  1.14   mjacob 		int bus = 0;
    131  1.14   mjacob 		(void) isp_control(isp, ISPCTL_RESET_BUS, &bus);
    132  1.21   mjacob 		if (IS_DUALBUS(isp)) {
    133  1.14   mjacob 			bus++;
    134  1.14   mjacob 			(void) isp_control(isp, ISPCTL_RESET_BUS, &bus);
    135  1.14   mjacob 		}
    136  1.19   mjacob 	} else {
    137  1.19   mjacob 		int i, j;
    138  1.19   mjacob 		fcparam *fcp = isp->isp_param;
    139  1.19   mjacob 		delay(2 * 1000000);
    140  1.19   mjacob 		for (j = 0; j < 5; j++) {
    141  1.19   mjacob 			for (i = 0; i < 5; i++) {
    142  1.19   mjacob 				if (isp_control(isp, ISPCTL_FCLINK_TEST, NULL))
    143  1.19   mjacob 					continue;
    144  1.19   mjacob #ifdef	ISP2100_FABRIC
    145  1.19   mjacob 				/*
    146  1.19   mjacob 				 * Wait extra time to see if the f/w
    147  1.19   mjacob 				 * eventually completed an FLOGI that
    148  1.19   mjacob 				 * will allow us to know we're on a
    149  1.19   mjacob 				 * fabric.
    150  1.19   mjacob 				 */
    151  1.19   mjacob 				if (fcp->isp_onfabric == 0) {
    152  1.19   mjacob 					delay(1 * 1000000);
    153  1.19   mjacob 					continue;
    154  1.19   mjacob 				}
    155  1.19   mjacob #endif
    156  1.19   mjacob 				break;
    157  1.19   mjacob 			}
    158  1.19   mjacob 			if (fcp->isp_fwstate == FW_READY &&
    159  1.19   mjacob 			    fcp->isp_loopstate >= LOOP_PDB_RCVD) {
    160  1.19   mjacob 				break;
    161  1.19   mjacob 			}
    162  1.19   mjacob 		}
    163  1.19   mjacob 		isp->isp_osinfo._link.scsipi_scsi.adapter_target =
    164  1.19   mjacob 			fcp->isp_loopid;
    165  1.11   mjacob 	}
    166  1.10   mjacob 
    167  1.10   mjacob 	/*
    168   1.8   mjacob 	 * And attach children (if any).
    169   1.8   mjacob 	 */
    170   1.1   mjacob 	config_found((void *)isp, &isp->isp_osinfo._link, scsiprint);
    171  1.21   mjacob 	if (IS_DUALBUS(isp)) {
    172  1.14   mjacob 		config_found((void *)isp, &isp->isp_osinfo._link_b, scsiprint);
    173  1.14   mjacob 	}
    174   1.1   mjacob }
    175   1.1   mjacob 
    176   1.1   mjacob /*
    177   1.1   mjacob  * minphys our xfers
    178   1.1   mjacob  *
    179   1.1   mjacob  * Unfortunately, the buffer pointer describes the target device- not the
    180   1.1   mjacob  * adapter device, so we can't use the pointer to find out what kind of
    181   1.1   mjacob  * adapter we are and adjust accordingly.
    182   1.1   mjacob  */
    183   1.1   mjacob 
    184   1.1   mjacob static void
    185   1.1   mjacob ispminphys(bp)
    186   1.1   mjacob 	struct buf *bp;
    187   1.1   mjacob {
    188   1.1   mjacob 	/*
    189   1.1   mjacob 	 * XX: Only the 1020 has a 24 bit limit.
    190   1.1   mjacob 	 */
    191   1.1   mjacob 	if (bp->b_bcount >= (1 << 24)) {
    192   1.1   mjacob 		bp->b_bcount = (1 << 24);
    193   1.1   mjacob 	}
    194   1.1   mjacob 	minphys(bp);
    195   1.1   mjacob }
    196   1.1   mjacob 
    197  1.17   mjacob static int32_t
    198  1.17   mjacob ispcmd_slow(xs)
    199   1.1   mjacob 	ISP_SCSI_XFER_T *xs;
    200   1.1   mjacob {
    201  1.19   mjacob 	sdparam *sdp;
    202  1.20   mjacob 	int tgt, chan, s;
    203  1.21   mjacob 	u_int16_t flags;
    204  1.19   mjacob 	struct ispsoftc *isp = XS_ISP(xs);
    205  1.19   mjacob 
    206  1.19   mjacob 	/*
    207  1.19   mjacob 	 * Have we completed discovery for this target on this adapter?
    208  1.19   mjacob 	 */
    209  1.20   mjacob 	tgt = XS_TGT(xs);
    210  1.20   mjacob 	chan = XS_CHANNEL(xs);
    211  1.19   mjacob 	if ((xs->xs_control & XS_CTL_DISCOVERY) != 0 ||
    212  1.19   mjacob 	    (isp->isp_osinfo.discovered[chan] & (1 << tgt)) != 0) {
    213  1.19   mjacob 		return (ispcmd(xs));
    214  1.19   mjacob 	}
    215  1.19   mjacob 
    216  1.21   mjacob 	flags = DPARM_DEFAULT;
    217  1.19   mjacob 	if (xs->sc_link->quirks & SDEV_NOSYNC) {
    218  1.21   mjacob 		flags ^= DPARM_SYNC;
    219  1.19   mjacob #ifdef	DEBUG
    220  1.19   mjacob 	} else {
    221  1.19   mjacob 		printf("%s: channel %d target %d can do SYNC xfers\n",
    222  1.19   mjacob 		    isp->isp_name, chan, tgt);
    223  1.19   mjacob #endif
    224  1.19   mjacob 	}
    225  1.19   mjacob 	if (xs->sc_link->quirks & SDEV_NOWIDE) {
    226  1.21   mjacob 		flags ^= DPARM_WIDE;
    227  1.19   mjacob #ifdef	DEBUG
    228  1.19   mjacob 	} else {
    229  1.19   mjacob 		printf("%s: channel %d target %d can do WIDE xfers\n",
    230  1.19   mjacob 		    isp->isp_name, chan, tgt);
    231  1.19   mjacob #endif
    232  1.19   mjacob 	}
    233  1.19   mjacob 	if (xs->sc_link->quirks & SDEV_NOTAG) {
    234  1.21   mjacob 		flags ^= DPARM_TQING;
    235  1.19   mjacob #ifdef	DEBUG
    236  1.19   mjacob 	} else {
    237  1.19   mjacob 		printf("%s: channel %d target %d can do TAGGED xfers\n",
    238  1.19   mjacob 		    isp->isp_name, chan, tgt);
    239  1.19   mjacob #endif
    240  1.19   mjacob 	}
    241  1.19   mjacob 	/*
    242  1.19   mjacob 	 * Okay, we know about this device now,
    243  1.19   mjacob 	 * so mark parameters to be updated for it.
    244  1.19   mjacob 	 */
    245  1.20   mjacob 	s = splbio();
    246  1.21   mjacob 	isp->isp_osinfo.discovered[chan] |= (1 << tgt);
    247  1.21   mjacob 	sdp = isp->isp_param;
    248  1.21   mjacob 	sdp += chan;
    249  1.21   mjacob 	sdp->isp_devparam[tgt].dev_flags = flags;
    250  1.19   mjacob 	sdp->isp_devparam[tgt].dev_update = 1;
    251  1.19   mjacob 	isp->isp_update |= (1 << chan);
    252  1.20   mjacob 	splx(s);
    253  1.17   mjacob 	return (ispcmd(xs));
    254  1.17   mjacob }
    255  1.17   mjacob 
    256  1.17   mjacob static int
    257  1.17   mjacob ispioctl(sc_link, cmd, addr, flag, p)
    258  1.17   mjacob 	struct scsipi_link *sc_link;
    259  1.17   mjacob 	u_long cmd;
    260  1.17   mjacob 	caddr_t addr;
    261  1.17   mjacob 	int flag;
    262  1.17   mjacob 	struct proc *p;
    263  1.17   mjacob {
    264  1.17   mjacob 	struct ispsoftc *isp = sc_link->adapter_softc;
    265  1.17   mjacob 	int s, chan, retval = ENOTTY;
    266  1.17   mjacob 
    267  1.17   mjacob 	switch (cmd) {
    268  1.17   mjacob 	case SCBUSIORESET:
    269  1.17   mjacob 		chan = sc_link->scsipi_scsi.channel;
    270  1.17   mjacob 		s = splbio();
    271  1.17   mjacob 		if (isp_control(isp, ISPCTL_RESET_BUS, &chan))
    272  1.17   mjacob 			retval = EIO;
    273  1.17   mjacob 		else
    274  1.17   mjacob 			retval = 0;
    275  1.17   mjacob 		(void) splx(s);
    276  1.17   mjacob 		break;
    277  1.17   mjacob 	default:
    278  1.17   mjacob 		break;
    279   1.3   mjacob 	}
    280  1.17   mjacob 	return (retval);
    281  1.17   mjacob }
    282  1.17   mjacob 
    283  1.17   mjacob 
    284  1.17   mjacob static int32_t
    285  1.17   mjacob ispcmd(xs)
    286  1.17   mjacob 	ISP_SCSI_XFER_T *xs;
    287  1.17   mjacob {
    288  1.17   mjacob 	struct ispsoftc *isp;
    289  1.17   mjacob 	int result, s;
    290  1.11   mjacob 
    291  1.17   mjacob 	isp = XS_ISP(xs);
    292  1.17   mjacob 	s = splbio();
    293  1.11   mjacob 	if (isp->isp_state < ISP_RUNSTATE) {
    294  1.11   mjacob 		DISABLE_INTS(isp);
    295  1.11   mjacob 		isp_init(isp);
    296  1.11   mjacob                 if (isp->isp_state != ISP_INITSTATE) {
    297  1.11   mjacob 			ENABLE_INTS(isp);
    298  1.11   mjacob                         (void) splx(s);
    299  1.11   mjacob                         XS_SETERR(xs, HBA_BOTCH);
    300  1.17   mjacob                         return (COMPLETE);
    301  1.11   mjacob                 }
    302  1.11   mjacob                 isp->isp_state = ISP_RUNSTATE;
    303  1.11   mjacob 		ENABLE_INTS(isp);
    304  1.11   mjacob         }
    305  1.11   mjacob 
    306  1.10   mjacob 	/*
    307  1.10   mjacob 	 * Check for queue blockage...
    308  1.10   mjacob 	 */
    309  1.10   mjacob 	if (isp->isp_osinfo.blocked) {
    310  1.16  thorpej 		if (xs->xs_control & XS_CTL_POLL) {
    311  1.10   mjacob 			xs->error = XS_DRIVER_STUFFUP;
    312  1.10   mjacob 			splx(s);
    313  1.10   mjacob 			return (TRY_AGAIN_LATER);
    314  1.10   mjacob 		}
    315  1.10   mjacob 		TAILQ_INSERT_TAIL(&isp->isp_osinfo.waitq, xs, adapter_q);
    316  1.10   mjacob 		splx(s);
    317  1.17   mjacob 		return (SUCCESSFULLY_QUEUED);
    318  1.10   mjacob 	}
    319  1.17   mjacob 
    320  1.26   mjacob 	if (xs->xs_control & XS_CTL_POLL) {
    321  1.26   mjacob 		result = isp_polled_cmd(isp, xs);
    322  1.10   mjacob 		(void) splx(s);
    323   1.3   mjacob 		return (result);
    324   1.1   mjacob 	}
    325   1.1   mjacob 
    326  1.26   mjacob 	result = ispscsicmd(xs);
    327  1.26   mjacob 	switch (result) {
    328  1.26   mjacob 	case CMD_QUEUED:
    329  1.26   mjacob 		result = SUCCESSFULLY_QUEUED;
    330  1.26   mjacob 		if (xs->timeout) {
    331  1.26   mjacob 			callout_reset(&xs->xs_callout, _XT(xs), isp_dog, xs);
    332  1.26   mjacob 		}
    333  1.26   mjacob 		break;
    334  1.26   mjacob 	case CMD_EAGAIN:
    335  1.26   mjacob 		result = TRY_AGAIN_LATER;
    336  1.26   mjacob 		break;
    337  1.26   mjacob 	case CMD_RQLATER:
    338  1.26   mjacob 		result = SUCCESSFULLY_QUEUED;
    339  1.26   mjacob 		callout_reset(&xs->xs_callout, hz, isp_command_requeue, xs);
    340  1.26   mjacob 		break;
    341  1.26   mjacob 	case CMD_COMPLETE:
    342  1.26   mjacob 		result = COMPLETE;
    343  1.26   mjacob 		break;
    344  1.26   mjacob 	}
    345  1.26   mjacob 	(void) splx(s);
    346  1.26   mjacob 	return (result);
    347  1.26   mjacob }
    348  1.26   mjacob 
    349  1.26   mjacob static int
    350  1.26   mjacob isp_polled_cmd(isp, xs)
    351  1.26   mjacob 	struct ispsoftc *isp;
    352  1.26   mjacob 	ISP_SCSI_XFER_T *xs;
    353  1.26   mjacob {
    354  1.26   mjacob 	int result;
    355  1.26   mjacob 	int infinite = 0, mswait;
    356  1.26   mjacob 
    357  1.26   mjacob 	result = ispscsicmd(xs);
    358  1.26   mjacob 
    359  1.17   mjacob 	switch (result) {
    360  1.17   mjacob 	case CMD_QUEUED:
    361  1.17   mjacob 		result = SUCCESSFULLY_QUEUED;
    362  1.17   mjacob 		break;
    363  1.17   mjacob 	case CMD_RQLATER:
    364  1.17   mjacob 	case CMD_EAGAIN:
    365  1.17   mjacob 		if (XS_NOERR(xs)) {
    366  1.17   mjacob 			xs->error = XS_DRIVER_STUFFUP;
    367  1.17   mjacob 		}
    368  1.17   mjacob 		result = TRY_AGAIN_LATER;
    369  1.17   mjacob 		break;
    370  1.17   mjacob 	case CMD_COMPLETE:
    371  1.17   mjacob 		result = COMPLETE;
    372  1.17   mjacob 		break;
    373  1.17   mjacob 
    374  1.17   mjacob 	}
    375  1.26   mjacob 
    376  1.26   mjacob 	if (result != SUCCESSFULLY_QUEUED) {
    377  1.26   mjacob 		return (result);
    378  1.26   mjacob 	}
    379  1.26   mjacob 
    380   1.1   mjacob 	/*
    381   1.1   mjacob 	 * If we can't use interrupts, poll on completion.
    382   1.1   mjacob 	 */
    383  1.26   mjacob 	if ((mswait = XS_TIME(xs)) == 0)
    384  1.26   mjacob 		infinite = 1;
    385  1.26   mjacob 
    386  1.26   mjacob 	while (mswait || infinite) {
    387  1.26   mjacob 		if (isp_intr((void *)isp)) {
    388  1.26   mjacob 			if (XS_CMD_DONE_P(xs)) {
    389  1.26   mjacob 				break;
    390   1.1   mjacob 			}
    391   1.1   mjacob 		}
    392  1.26   mjacob 		SYS_DELAY(1000);
    393  1.26   mjacob 		mswait -= 1;
    394  1.26   mjacob 	}
    395  1.26   mjacob 
    396  1.26   mjacob 	/*
    397  1.26   mjacob 	 * If no other error occurred but we didn't finish,
    398  1.26   mjacob 	 * something bad happened.
    399  1.26   mjacob 	 */
    400  1.26   mjacob 	if (XS_CMD_DONE_P(xs) == 0) {
    401  1.26   mjacob 		if (isp_control(isp, ISPCTL_ABORT_CMD, xs)) {
    402  1.26   mjacob 			isp_restart(isp);
    403  1.26   mjacob 		}
    404  1.26   mjacob 		if (XS_NOERR(xs)) {
    405  1.26   mjacob 			XS_SETERR(xs, HBA_BOTCH);
    406  1.26   mjacob 		}
    407   1.1   mjacob 	}
    408  1.26   mjacob 	result = COMPLETE;
    409  1.17   mjacob 	return (result);
    410   1.1   mjacob }
    411   1.1   mjacob 
    412  1.26   mjacob void
    413  1.26   mjacob isp_done(xs)
    414   1.1   mjacob 	ISP_SCSI_XFER_T *xs;
    415   1.1   mjacob {
    416  1.26   mjacob 	XS_CMD_S_DONE(xs);
    417  1.26   mjacob 	if (XS_CMD_WDOG_P(xs) == 0) {
    418  1.26   mjacob 		struct ispsoftc *isp = XS_ISP(xs);
    419  1.26   mjacob 		callout_stop(&xs->xs_callout);
    420  1.26   mjacob 		if (XS_CMD_GRACE_P(xs)) {
    421  1.26   mjacob 			PRINTF("%s: finished command on borrowed time\n",
    422  1.26   mjacob 			    isp->isp_name);
    423   1.1   mjacob 		}
    424  1.26   mjacob 		XS_CMD_S_CLEAR(xs);
    425  1.26   mjacob 		scsipi_done(xs);
    426   1.1   mjacob 	}
    427   1.8   mjacob }
    428   1.8   mjacob 
    429   1.8   mjacob static void
    430  1.26   mjacob isp_dog(arg)
    431   1.8   mjacob 	void *arg;
    432   1.8   mjacob {
    433  1.26   mjacob 	ISP_SCSI_XFER_T *xs = arg;
    434  1.26   mjacob 	struct ispsoftc *isp = XS_ISP(xs);
    435  1.26   mjacob 	u_int32_t handle;
    436  1.26   mjacob 	int s = splbio();
    437   1.8   mjacob 
    438   1.8   mjacob 	/*
    439  1.26   mjacob 	 * We've decided this command is dead. Make sure we're not trying
    440  1.26   mjacob 	 * to kill a command that's already dead by getting it's handle and
    441  1.26   mjacob 	 * and seeing whether it's still alive.
    442  1.26   mjacob 	 */
    443  1.26   mjacob 	handle = isp_find_handle(isp, xs);
    444  1.26   mjacob 	if (handle) {
    445  1.26   mjacob 		u_int16_t r, r1, i;
    446  1.26   mjacob 
    447  1.26   mjacob 		if (XS_CMD_DONE_P(xs)) {
    448  1.26   mjacob 			PRINTF("%s: watchdog found done cmd (handle 0x%x)\n",
    449  1.26   mjacob 			    isp->isp_name, handle);
    450  1.26   mjacob 			(void) splx(s);
    451  1.26   mjacob 			return;
    452  1.26   mjacob 		}
    453  1.26   mjacob 
    454  1.26   mjacob 		if (XS_CMD_WDOG_P(xs)) {
    455  1.26   mjacob 			PRINTF("%s: recursive watchdog (handle 0x%x)\n",
    456  1.26   mjacob 			    isp->isp_name, handle);
    457  1.26   mjacob 			(void) splx(s);
    458  1.26   mjacob 			return;
    459  1.26   mjacob 		}
    460  1.26   mjacob 
    461  1.26   mjacob 		XS_CMD_S_WDOG(xs);
    462  1.26   mjacob 
    463  1.26   mjacob 		i = 0;
    464  1.26   mjacob 		do {
    465  1.26   mjacob 			r = ISP_READ(isp, BIU_ISR);
    466  1.26   mjacob 			SYS_DELAY(1);
    467  1.26   mjacob 			r1 = ISP_READ(isp, BIU_ISR);
    468  1.26   mjacob 		} while (r != r1 && ++i < 1000);
    469  1.26   mjacob 
    470  1.26   mjacob 		if (INT_PENDING(isp, r) && isp_intr(isp) && XS_CMD_DONE_P(xs)) {
    471  1.26   mjacob 			IDPRINTF(1, ("%s: watchdog cleanup (%x, %x)\n",
    472  1.26   mjacob 			    isp->isp_name, handle, r));
    473  1.26   mjacob 			XS_CMD_C_WDOG(xs);
    474  1.26   mjacob 			isp_done(xs);
    475  1.26   mjacob 		} else if (XS_CMD_GRACE_P(xs)) {
    476  1.26   mjacob 			IDPRINTF(1, ("%s: watchdog timeout (%x, %x)\n",
    477  1.26   mjacob 			    isp->isp_name, handle, r));
    478  1.26   mjacob 			/*
    479  1.26   mjacob 			 * Make sure the command is *really* dead before we
    480  1.26   mjacob 			 * release the handle (and DMA resources) for reuse.
    481  1.26   mjacob 			 */
    482  1.26   mjacob 			(void) isp_control(isp, ISPCTL_ABORT_CMD, arg);
    483  1.26   mjacob 
    484  1.26   mjacob 			/*
    485  1.26   mjacob 			 * After this point, the comamnd is really dead.
    486  1.26   mjacob 			 */
    487  1.26   mjacob 			if (XS_XFRLEN(xs)) {
    488  1.26   mjacob 				ISP_DMAFREE(isp, xs, handle);
    489  1.26   mjacob 			}
    490  1.26   mjacob 			isp_destroy_handle(isp, handle);
    491  1.26   mjacob 			XS_SETERR(xs, XS_TIMEOUT);
    492  1.26   mjacob 			XS_CMD_S_CLEAR(xs);
    493  1.26   mjacob 			isp_done(xs);
    494  1.26   mjacob 		} else {
    495  1.26   mjacob 			u_int16_t iptr, optr;
    496  1.26   mjacob 			ispreq_t *mp;
    497  1.26   mjacob 
    498  1.26   mjacob 			IDPRINTF(2, ("%s: possible command timeout (%x, %x)\n",
    499  1.26   mjacob 			    isp->isp_name, handle, r));
    500  1.26   mjacob 
    501  1.26   mjacob 			XS_CMD_C_WDOG(xs);
    502  1.26   mjacob 			callout_reset(&xs->xs_callout, hz, isp_dog, xs);
    503  1.26   mjacob 			if (isp_getrqentry(isp, &iptr, &optr, (void **) &mp)) {
    504  1.26   mjacob 				(void) splx(s);
    505  1.26   mjacob 				return;
    506  1.26   mjacob 			}
    507  1.26   mjacob 			XS_CMD_S_GRACE(xs);
    508  1.26   mjacob 			MEMZERO((void *) mp, sizeof (*mp));
    509  1.26   mjacob 			mp->req_header.rqs_entry_count = 1;
    510  1.26   mjacob 			mp->req_header.rqs_entry_type = RQSTYPE_MARKER;
    511  1.26   mjacob 			mp->req_modifier = SYNC_ALL;
    512  1.26   mjacob 			mp->req_target = XS_CHANNEL(xs) << 7;
    513  1.26   mjacob 			ISP_SWIZZLE_REQUEST(isp, mp);
    514  1.26   mjacob 			MemoryBarrier();
    515  1.26   mjacob 			ISP_ADD_REQUEST(isp, iptr);
    516   1.8   mjacob 		}
    517  1.26   mjacob 	} else if (isp->isp_dblev) {
    518  1.26   mjacob 		PRINTF("%s: watchdog with no command\n", isp->isp_name);
    519   1.8   mjacob 	}
    520  1.17   mjacob 	(void) splx(s);
    521   1.8   mjacob }
    522   1.8   mjacob 
    523   1.8   mjacob /*
    524   1.8   mjacob  * Free any associated resources prior to decommissioning and
    525   1.8   mjacob  * set the card to a known state (so it doesn't wake up and kick
    526   1.8   mjacob  * us when we aren't expecting it to).
    527   1.8   mjacob  *
    528   1.8   mjacob  * Locks are held before coming here.
    529   1.8   mjacob  */
    530   1.8   mjacob void
    531   1.8   mjacob isp_uninit(isp)
    532   1.8   mjacob 	struct ispsoftc *isp;
    533   1.8   mjacob {
    534   1.8   mjacob 	ISP_ILOCKVAL_DECL;
    535   1.8   mjacob 	ISP_ILOCK(isp);
    536   1.8   mjacob 	/*
    537   1.8   mjacob 	 * Leave with interrupts disabled.
    538   1.8   mjacob 	 */
    539   1.8   mjacob 	DISABLE_INTS(isp);
    540   1.8   mjacob 
    541   1.8   mjacob 	ISP_IUNLOCK(isp);
    542   1.9   mjacob }
    543   1.9   mjacob 
    544  1.10   mjacob /*
    545  1.17   mjacob  * Restart function for a command to be requeued later.
    546  1.17   mjacob  */
    547  1.17   mjacob static void
    548  1.17   mjacob isp_command_requeue(arg)
    549  1.17   mjacob 	void *arg;
    550  1.17   mjacob {
    551  1.17   mjacob 	struct scsipi_xfer *xs = arg;
    552  1.17   mjacob 	struct ispsoftc *isp = XS_ISP(xs);
    553  1.17   mjacob 	int s = splbio();
    554  1.17   mjacob 	switch (ispcmd_slow(xs)) {
    555  1.17   mjacob 	case SUCCESSFULLY_QUEUED:
    556  1.18   mjacob 		printf("%s: isp_command_requeue: requeued for %d.%d\n",
    557  1.17   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
    558  1.26   mjacob 		if (xs->timeout) {
    559  1.26   mjacob 			callout_reset(&xs->xs_callout, _XT(xs), isp_dog, xs);
    560  1.26   mjacob 		}
    561  1.17   mjacob 		break;
    562  1.17   mjacob 	case TRY_AGAIN_LATER:
    563  1.17   mjacob 		printf("%s: EAGAIN for %d.%d\n",
    564  1.17   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
    565  1.17   mjacob 		/* FALLTHROUGH */
    566  1.17   mjacob 	case COMPLETE:
    567  1.18   mjacob 		/* can only be an error */
    568  1.26   mjacob 		XS_CMD_S_DONE(xs);
    569  1.26   mjacob 		callout_stop(&xs->xs_callout);
    570  1.17   mjacob 		if (XS_NOERR(xs)) {
    571  1.17   mjacob 			XS_SETERR(xs, HBA_BOTCH);
    572  1.17   mjacob 		}
    573  1.17   mjacob 		scsipi_done(xs);
    574  1.17   mjacob 		break;
    575  1.17   mjacob 	}
    576  1.17   mjacob 	(void) splx(s);
    577  1.17   mjacob }
    578  1.18   mjacob 
    579  1.17   mjacob /*
    580  1.10   mjacob  * Restart function after a LOOP UP event (e.g.),
    581  1.10   mjacob  * done as a timeout for some hysteresis.
    582  1.10   mjacob  */
    583  1.10   mjacob static void
    584  1.10   mjacob isp_internal_restart(arg)
    585  1.10   mjacob 	void *arg;
    586  1.10   mjacob {
    587  1.10   mjacob 	struct ispsoftc *isp = arg;
    588  1.11   mjacob 	int result, nrestarted = 0, s;
    589  1.10   mjacob 
    590  1.11   mjacob 	s = splbio();
    591  1.10   mjacob 	if (isp->isp_osinfo.blocked == 0) {
    592  1.10   mjacob 		struct scsipi_xfer *xs;
    593  1.10   mjacob 		while ((xs = TAILQ_FIRST(&isp->isp_osinfo.waitq)) != NULL) {
    594  1.10   mjacob 			TAILQ_REMOVE(&isp->isp_osinfo.waitq, xs, adapter_q);
    595  1.11   mjacob 			result = ispscsicmd(xs);
    596  1.11   mjacob 			if (result != CMD_QUEUED) {
    597  1.10   mjacob 				printf("%s: botched command restart (0x%x)\n",
    598  1.10   mjacob 				    isp->isp_name, result);
    599  1.26   mjacob 				XS_CMD_S_DONE(xs);
    600  1.10   mjacob 				if (xs->error == XS_NOERROR)
    601  1.10   mjacob 					xs->error = XS_DRIVER_STUFFUP;
    602  1.26   mjacob 				callout_stop(&xs->xs_callout);
    603  1.10   mjacob 				scsipi_done(xs);
    604  1.26   mjacob 			} else if (xs->timeout) {
    605  1.26   mjacob 				callout_reset(&xs->xs_callout,
    606  1.26   mjacob 				    _XT(xs), isp_dog, xs);
    607  1.10   mjacob 			}
    608  1.10   mjacob 			nrestarted++;
    609  1.10   mjacob 		}
    610  1.10   mjacob 		printf("%s: requeued %d commands\n", isp->isp_name, nrestarted);
    611  1.10   mjacob 	}
    612  1.10   mjacob 	(void) splx(s);
    613  1.10   mjacob }
    614  1.18   mjacob 
    615   1.9   mjacob int
    616   1.9   mjacob isp_async(isp, cmd, arg)
    617   1.9   mjacob 	struct ispsoftc *isp;
    618   1.9   mjacob 	ispasync_t cmd;
    619   1.9   mjacob 	void *arg;
    620   1.9   mjacob {
    621  1.14   mjacob 	int bus, tgt;
    622  1.10   mjacob 	int s = splbio();
    623   1.9   mjacob 	switch (cmd) {
    624   1.9   mjacob 	case ISPASYNC_NEW_TGT_PARAMS:
    625  1.17   mjacob 	if (IS_SCSI(isp) && isp->isp_dblev) {
    626  1.17   mjacob 		sdparam *sdp = isp->isp_param;
    627  1.17   mjacob 		char *wt;
    628  1.17   mjacob 		int mhz, flags, period;
    629  1.17   mjacob 
    630  1.17   mjacob 		tgt = *((int *) arg);
    631  1.17   mjacob 		bus = (tgt >> 16) & 0xffff;
    632  1.17   mjacob 		tgt &= 0xffff;
    633  1.21   mjacob 		sdp += bus;
    634  1.17   mjacob 		flags = sdp->isp_devparam[tgt].cur_dflags;
    635  1.17   mjacob 		period = sdp->isp_devparam[tgt].cur_period;
    636  1.21   mjacob 
    637  1.17   mjacob 		if ((flags & DPARM_SYNC) && period &&
    638  1.17   mjacob 		    (sdp->isp_devparam[tgt].cur_offset) != 0) {
    639  1.21   mjacob #if	0
    640  1.21   mjacob 			/* CAUSES PANICS */
    641  1.21   mjacob 			static char *m = "%s: bus %d now %s mode\n";
    642  1.21   mjacob 			u_int16_t r, l;
    643  1.21   mjacob 			if (bus == 1)
    644  1.21   mjacob 				r = SXP_PINS_DIFF | SXP_BANK1_SELECT;
    645  1.21   mjacob 			else
    646  1.21   mjacob 				r = SXP_PINS_DIFF;
    647  1.21   mjacob 			l = ISP_READ(isp, r) & ISP1080_MODE_MASK;
    648  1.21   mjacob 			switch (l) {
    649  1.21   mjacob 			case ISP1080_LVD_MODE:
    650  1.21   mjacob 				sdp->isp_lvdmode = 1;
    651  1.21   mjacob 				printf(m, isp->isp_name, bus, "LVD");
    652  1.21   mjacob 				break;
    653  1.21   mjacob 			case ISP1080_HVD_MODE:
    654  1.21   mjacob 				sdp->isp_diffmode = 1;
    655  1.21   mjacob 				printf(m, isp->isp_name, bus, "Differential");
    656  1.21   mjacob 				break;
    657  1.21   mjacob 			case ISP1080_SE_MODE:
    658  1.21   mjacob 				sdp->isp_ultramode = 1;
    659  1.21   mjacob 				printf(m, isp->isp_name, bus, "Single-Ended");
    660  1.21   mjacob 				break;
    661  1.21   mjacob 			default:
    662  1.21   mjacob 				printf("%s: unknown mode on bus %d (0x%x)\n",
    663  1.21   mjacob 				    isp->isp_name, bus, l);
    664  1.21   mjacob 				break;
    665  1.21   mjacob 			}
    666  1.21   mjacob #endif
    667  1.21   mjacob 			/*
    668  1.21   mjacob 			 * There's some ambiguity about our negotiated speed
    669  1.21   mjacob 			 * if we haven't detected LVD mode correctly (which
    670  1.21   mjacob 			 * seems to happen, unfortunately). If we're in LVD
    671  1.21   mjacob 			 * mode, then different rules apply about speed.
    672  1.21   mjacob 			 */
    673  1.21   mjacob 			if (sdp->isp_lvdmode || period < 0xc) {
    674  1.17   mjacob 				switch (period) {
    675  1.23   mjacob 				case 0x9:
    676  1.23   mjacob 					mhz = 80;
    677  1.23   mjacob 					break;
    678  1.17   mjacob 				case 0xa:
    679  1.17   mjacob 					mhz = 40;
    680  1.17   mjacob 					break;
    681  1.17   mjacob 				case 0xb:
    682  1.17   mjacob 					mhz = 33;
    683  1.17   mjacob 					break;
    684  1.17   mjacob 				case 0xc:
    685  1.17   mjacob 					mhz = 25;
    686  1.17   mjacob 					break;
    687  1.17   mjacob 				default:
    688  1.12   mjacob 					mhz = 1000 / (period * 4);
    689  1.17   mjacob 					break;
    690  1.12   mjacob 				}
    691   1.9   mjacob 			} else {
    692  1.17   mjacob 				mhz = 1000 / (period * 4);
    693   1.9   mjacob 			}
    694  1.17   mjacob 		} else {
    695  1.17   mjacob 			mhz = 0;
    696  1.17   mjacob 		}
    697  1.17   mjacob 		switch (flags & (DPARM_WIDE|DPARM_TQING)) {
    698  1.17   mjacob 		case DPARM_WIDE:
    699  1.17   mjacob 			wt = ", 16 bit wide\n";
    700  1.17   mjacob 			break;
    701  1.17   mjacob 		case DPARM_TQING:
    702  1.17   mjacob 			wt = ", Tagged Queueing Enabled\n";
    703  1.17   mjacob 			break;
    704  1.17   mjacob 		case DPARM_WIDE|DPARM_TQING:
    705  1.17   mjacob 			wt = ", 16 bit wide, Tagged Queueing Enabled\n";
    706  1.17   mjacob 			break;
    707  1.17   mjacob 		default:
    708  1.17   mjacob 			wt = "\n";
    709  1.17   mjacob 			break;
    710  1.17   mjacob 		}
    711  1.17   mjacob 		if (mhz) {
    712  1.19   mjacob 			CFGPRINTF("%s: Bus %d Target %d at %dMHz Max "
    713  1.17   mjacob 			    "Offset %d%s", isp->isp_name, bus, tgt, mhz,
    714  1.17   mjacob 			    sdp->isp_devparam[tgt].cur_offset, wt);
    715  1.17   mjacob 		} else {
    716  1.19   mjacob 			CFGPRINTF("%s: Bus %d Target %d Async Mode%s",
    717  1.17   mjacob 			    isp->isp_name, bus, tgt, wt);
    718   1.9   mjacob 		}
    719  1.11   mjacob 		break;
    720  1.17   mjacob 	}
    721  1.11   mjacob 	case ISPASYNC_BUS_RESET:
    722  1.14   mjacob 		if (arg)
    723  1.14   mjacob 			bus = *((int *) arg);
    724  1.14   mjacob 		else
    725  1.14   mjacob 			bus = 0;
    726  1.14   mjacob 		printf("%s: SCSI bus %d reset detected\n", isp->isp_name, bus);
    727  1.11   mjacob 		break;
    728  1.11   mjacob 	case ISPASYNC_LOOP_DOWN:
    729  1.11   mjacob 		/*
    730  1.11   mjacob 		 * Hopefully we get here in time to minimize the number
    731  1.11   mjacob 		 * of commands we are firing off that are sure to die.
    732  1.11   mjacob 		 */
    733  1.11   mjacob 		isp->isp_osinfo.blocked = 1;
    734  1.11   mjacob 		printf("%s: Loop DOWN\n", isp->isp_name);
    735  1.11   mjacob 		break;
    736  1.11   mjacob         case ISPASYNC_LOOP_UP:
    737  1.11   mjacob 		isp->isp_osinfo.blocked = 0;
    738  1.24  thorpej 		callout_reset(&isp->isp_osinfo._restart, 1,
    739  1.24  thorpej 		    isp_internal_restart, isp);
    740  1.11   mjacob 		printf("%s: Loop UP\n", isp->isp_name);
    741  1.11   mjacob 		break;
    742  1.15   mjacob 	case ISPASYNC_PDB_CHANGED:
    743  1.17   mjacob 	if (IS_FC(isp) && isp->isp_dblev) {
    744  1.15   mjacob 		const char *fmt = "%s: Target %d (Loop 0x%x) Port ID 0x%x "
    745  1.15   mjacob 		    "role %s %s\n Port WWN 0x%08x%08x\n Node WWN 0x%08x%08x\n";
    746  1.15   mjacob 		const static char *roles[4] = {
    747  1.11   mjacob 		    "No", "Target", "Initiator", "Target/Initiator"
    748  1.11   mjacob 		};
    749  1.15   mjacob 		char *ptr;
    750  1.15   mjacob 		fcparam *fcp = isp->isp_param;
    751  1.15   mjacob 		int tgt = *((int *) arg);
    752  1.15   mjacob 		struct lportdb *lp = &fcp->portdb[tgt];
    753  1.15   mjacob 
    754  1.15   mjacob 		if (lp->valid) {
    755  1.15   mjacob 			ptr = "arrived";
    756  1.15   mjacob 		} else {
    757  1.15   mjacob 			ptr = "disappeared";
    758  1.11   mjacob 		}
    759  1.15   mjacob 		printf(fmt, isp->isp_name, tgt, lp->loopid, lp->portid,
    760  1.15   mjacob 		    roles[lp->roles & 0x3], ptr,
    761  1.15   mjacob 		    (u_int32_t) (lp->port_wwn >> 32),
    762  1.15   mjacob 		    (u_int32_t) (lp->port_wwn & 0xffffffffLL),
    763  1.15   mjacob 		    (u_int32_t) (lp->node_wwn >> 32),
    764  1.15   mjacob 		    (u_int32_t) (lp->node_wwn & 0xffffffffLL));
    765  1.11   mjacob 		break;
    766  1.11   mjacob 	}
    767  1.15   mjacob #ifdef	ISP2100_FABRIC
    768  1.11   mjacob 	case ISPASYNC_CHANGE_NOTIFY:
    769  1.11   mjacob 		printf("%s: Name Server Database Changed\n", isp->isp_name);
    770   1.9   mjacob 		break;
    771  1.15   mjacob 	case ISPASYNC_FABRIC_DEV:
    772  1.15   mjacob 	{
    773  1.15   mjacob 		int target;
    774  1.15   mjacob 		struct lportdb *lp;
    775  1.15   mjacob 		sns_scrsp_t *resp = (sns_scrsp_t *) arg;
    776  1.15   mjacob 		u_int32_t portid;
    777  1.15   mjacob 		u_int64_t wwn;
    778  1.15   mjacob 		fcparam *fcp = isp->isp_param;
    779  1.15   mjacob 
    780  1.15   mjacob 		portid =
    781  1.15   mjacob 		    (((u_int32_t) resp->snscb_port_id[0]) << 16) |
    782  1.15   mjacob 		    (((u_int32_t) resp->snscb_port_id[1]) << 8) |
    783  1.15   mjacob 		    (((u_int32_t) resp->snscb_port_id[2]));
    784  1.15   mjacob 		wwn =
    785  1.15   mjacob 		    (((u_int64_t)resp->snscb_portname[0]) << 56) |
    786  1.15   mjacob 		    (((u_int64_t)resp->snscb_portname[1]) << 48) |
    787  1.15   mjacob 		    (((u_int64_t)resp->snscb_portname[2]) << 40) |
    788  1.15   mjacob 		    (((u_int64_t)resp->snscb_portname[3]) << 32) |
    789  1.15   mjacob 		    (((u_int64_t)resp->snscb_portname[4]) << 24) |
    790  1.15   mjacob 		    (((u_int64_t)resp->snscb_portname[5]) << 16) |
    791  1.15   mjacob 		    (((u_int64_t)resp->snscb_portname[6]) <<  8) |
    792  1.15   mjacob 		    (((u_int64_t)resp->snscb_portname[7]));
    793  1.15   mjacob 		printf("%s: Fabric Device (Type 0x%x)@PortID 0x%x WWN "
    794  1.15   mjacob 		    "0x%08x%08x\n", isp->isp_name, resp->snscb_port_type,
    795  1.15   mjacob 		    portid, ((u_int32_t)(wwn >> 32)),
    796  1.15   mjacob 		    ((u_int32_t)(wwn & 0xffffffff)));
    797  1.15   mjacob 		if (resp->snscb_port_type != 2)
    798  1.15   mjacob 			break;
    799  1.15   mjacob 		for (target = FC_SNS_ID+1; target < MAX_FC_TARG; target++) {
    800  1.15   mjacob 			lp = &fcp->portdb[target];
    801  1.15   mjacob 			if (lp->port_wwn == wwn)
    802  1.15   mjacob 				break;
    803  1.15   mjacob 		}
    804  1.15   mjacob 		if (target < MAX_FC_TARG) {
    805  1.15   mjacob 			break;
    806  1.15   mjacob 		}
    807  1.15   mjacob 		for (target = FC_SNS_ID+1; target < MAX_FC_TARG; target++) {
    808  1.15   mjacob 			lp = &fcp->portdb[target];
    809  1.15   mjacob 			if (lp->port_wwn == 0)
    810  1.15   mjacob 				break;
    811  1.15   mjacob 		}
    812  1.15   mjacob 		if (target == MAX_FC_TARG) {
    813  1.15   mjacob 			printf("%s: no more space for fabric devices\n",
    814  1.15   mjacob 			    isp->isp_name);
    815  1.15   mjacob 			return (-1);
    816  1.15   mjacob 		}
    817  1.15   mjacob 		lp->port_wwn = lp->node_wwn = wwn;
    818  1.15   mjacob 		lp->portid = portid;
    819  1.15   mjacob 		break;
    820  1.15   mjacob 	}
    821  1.15   mjacob #endif
    822   1.9   mjacob 	default:
    823   1.9   mjacob 		break;
    824   1.9   mjacob 	}
    825  1.10   mjacob 	(void) splx(s);
    826   1.9   mjacob 	return (0);
    827   1.1   mjacob }
    828