Home | History | Annotate | Line # | Download | only in ic
siop_common.c revision 1.46.10.2
      1  1.46.10.2       jym /*	$NetBSD: siop_common.c,v 1.46.10.2 2009/07/23 23:31:48 jym Exp $	*/
      2        1.1    bouyer 
      3        1.1    bouyer /*
      4       1.22    bouyer  * Copyright (c) 2000, 2002 Manuel Bouyer.
      5        1.1    bouyer  *
      6        1.1    bouyer  * Redistribution and use in source and binary forms, with or without
      7        1.1    bouyer  * modification, are permitted provided that the following conditions
      8        1.1    bouyer  * are met:
      9        1.1    bouyer  * 1. Redistributions of source code must retain the above copyright
     10        1.1    bouyer  *    notice, this list of conditions and the following disclaimer.
     11        1.1    bouyer  * 2. Redistributions in binary form must reproduce the above copyright
     12        1.1    bouyer  *    notice, this list of conditions and the following disclaimer in the
     13        1.1    bouyer  *    documentation and/or other materials provided with the distribution.
     14        1.1    bouyer  * 3. All advertising materials mentioning features or use of this software
     15        1.1    bouyer  *    must display the following acknowledgement:
     16       1.23    bouyer  *	This product includes software developed by Manuel Bouyer.
     17        1.1    bouyer  * 4. The name of the author may not be used to endorse or promote products
     18        1.1    bouyer  *    derived from this software without specific prior written permission.
     19        1.1    bouyer  *
     20        1.1    bouyer  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     21        1.1    bouyer  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     22        1.1    bouyer  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     23       1.37     perry  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     24        1.1    bouyer  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     25        1.1    bouyer  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     26        1.1    bouyer  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     27        1.1    bouyer  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     28        1.1    bouyer  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     29        1.1    bouyer  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     30        1.1    bouyer  *
     31        1.1    bouyer  */
     32        1.1    bouyer 
     33        1.1    bouyer /* SYM53c7/8xx PCI-SCSI I/O Processors driver */
     34       1.15     lukem 
     35       1.15     lukem #include <sys/cdefs.h>
     36  1.46.10.2       jym __KERNEL_RCSID(0, "$NetBSD: siop_common.c,v 1.46.10.2 2009/07/23 23:31:48 jym Exp $");
     37        1.1    bouyer 
     38        1.1    bouyer #include <sys/param.h>
     39        1.1    bouyer #include <sys/systm.h>
     40        1.1    bouyer #include <sys/device.h>
     41        1.1    bouyer #include <sys/malloc.h>
     42        1.1    bouyer #include <sys/buf.h>
     43        1.1    bouyer #include <sys/kernel.h>
     44        1.1    bouyer #include <sys/scsiio.h>
     45        1.1    bouyer 
     46       1.22    bouyer #include <uvm/uvm_extern.h>
     47       1.22    bouyer 
     48        1.1    bouyer #include <machine/endian.h>
     49       1.43        ad #include <sys/bus.h>
     50        1.1    bouyer 
     51        1.1    bouyer #include <dev/scsipi/scsi_all.h>
     52        1.1    bouyer #include <dev/scsipi/scsi_message.h>
     53        1.1    bouyer #include <dev/scsipi/scsipi_all.h>
     54        1.1    bouyer 
     55        1.1    bouyer #include <dev/scsipi/scsiconf.h>
     56        1.1    bouyer 
     57        1.1    bouyer #include <dev/ic/siopreg.h>
     58        1.1    bouyer #include <dev/ic/siopvar_common.h>
     59        1.1    bouyer 
     60       1.16    bouyer #include "opt_siop.h"
     61       1.16    bouyer 
     62        1.2    bouyer #undef DEBUG
     63        1.2    bouyer #undef DEBUG_DR
     64       1.22    bouyer #undef DEBUG_NEG
     65       1.22    bouyer 
     66       1.22    bouyer int
     67  1.46.10.1       jym siop_common_attach(struct siop_common_softc *sc)
     68       1.22    bouyer {
     69       1.22    bouyer 	int error, i;
     70       1.22    bouyer 	bus_dma_segment_t seg;
     71       1.22    bouyer 	int rseg;
     72       1.22    bouyer 
     73       1.22    bouyer 	/*
     74       1.22    bouyer 	 * Allocate DMA-safe memory for the script and map it.
     75       1.22    bouyer 	 */
     76       1.22    bouyer 	if ((sc->features & SF_CHIP_RAM) == 0) {
     77       1.37     perry 		error = bus_dmamem_alloc(sc->sc_dmat, PAGE_SIZE,
     78       1.22    bouyer 		    PAGE_SIZE, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT);
     79       1.22    bouyer 		if (error) {
     80  1.46.10.2       jym 			aprint_error_dev(sc->sc_dev,
     81       1.45    cegger 			    "unable to allocate script DMA memory, "
     82       1.45    cegger 			    "error = %d\n", error);
     83       1.22    bouyer 			return error;
     84       1.22    bouyer 		}
     85       1.22    bouyer 		error = bus_dmamem_map(sc->sc_dmat, &seg, rseg, PAGE_SIZE,
     86       1.42  christos 		    (void **)&sc->sc_script,
     87       1.22    bouyer 		    BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
     88       1.22    bouyer 		if (error) {
     89  1.46.10.2       jym 			aprint_error_dev(sc->sc_dev,
     90  1.46.10.2       jym 			    "unable to map script DMA memory, "
     91       1.45    cegger 			    "error = %d\n", error);
     92       1.22    bouyer 			return error;
     93       1.22    bouyer 		}
     94       1.22    bouyer 		error = bus_dmamap_create(sc->sc_dmat, PAGE_SIZE, 1,
     95       1.22    bouyer 		    PAGE_SIZE, 0, BUS_DMA_NOWAIT, &sc->sc_scriptdma);
     96       1.22    bouyer 		if (error) {
     97  1.46.10.2       jym 			aprint_error_dev(sc->sc_dev,
     98  1.46.10.2       jym 			    "unable to create script DMA map, "
     99       1.45    cegger 			    "error = %d\n", error);
    100       1.22    bouyer 			return error;
    101       1.22    bouyer 		}
    102       1.22    bouyer 		error = bus_dmamap_load(sc->sc_dmat, sc->sc_scriptdma,
    103       1.22    bouyer 		    sc->sc_script, PAGE_SIZE, NULL, BUS_DMA_NOWAIT);
    104       1.22    bouyer 		if (error) {
    105  1.46.10.2       jym 			aprint_error_dev(sc->sc_dev,
    106  1.46.10.2       jym 			    "unable to load script DMA map, "
    107       1.45    cegger 			    "error = %d\n", error);
    108       1.22    bouyer 			return error;
    109       1.22    bouyer 		}
    110       1.22    bouyer 		sc->sc_scriptaddr =
    111       1.22    bouyer 		    sc->sc_scriptdma->dm_segs[0].ds_addr;
    112       1.22    bouyer 		sc->ram_size = PAGE_SIZE;
    113       1.22    bouyer 	}
    114       1.22    bouyer 
    115  1.46.10.2       jym 	sc->sc_adapt.adapt_dev = sc->sc_dev;
    116       1.22    bouyer 	sc->sc_adapt.adapt_nchannels = 1;
    117       1.22    bouyer 	sc->sc_adapt.adapt_openings = 0;
    118       1.22    bouyer 	sc->sc_adapt.adapt_ioctl = siop_ioctl;
    119       1.22    bouyer 	sc->sc_adapt.adapt_minphys = minphys;
    120       1.22    bouyer 
    121       1.22    bouyer 	memset(&sc->sc_chan, 0, sizeof(sc->sc_chan));
    122       1.22    bouyer 	sc->sc_chan.chan_adapter = &sc->sc_adapt;
    123       1.22    bouyer 	sc->sc_chan.chan_bustype = &scsi_bustype;
    124       1.22    bouyer 	sc->sc_chan.chan_channel = 0;
    125       1.22    bouyer 	sc->sc_chan.chan_flags = SCSIPI_CHAN_CANGROW;
    126       1.22    bouyer 	sc->sc_chan.chan_ntargets =
    127       1.22    bouyer 	    (sc->features & SF_BUS_WIDE) ? 16 : 8;
    128       1.22    bouyer 	sc->sc_chan.chan_nluns = 8;
    129       1.22    bouyer 	sc->sc_chan.chan_id =
    130       1.22    bouyer 	    bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SCID);
    131       1.22    bouyer 	if (sc->sc_chan.chan_id == 0 ||
    132       1.22    bouyer 	    sc->sc_chan.chan_id >= sc->sc_chan.chan_ntargets)
    133       1.22    bouyer 		sc->sc_chan.chan_id = SIOP_DEFAULT_TARGET;
    134       1.22    bouyer 
    135       1.22    bouyer 	for (i = 0; i < 16; i++)
    136       1.22    bouyer 		sc->targets[i] = NULL;
    137       1.22    bouyer 
    138       1.22    bouyer 	/* find min/max sync period for this chip */
    139       1.22    bouyer 	sc->st_maxsync = 0;
    140       1.22    bouyer 	sc->dt_maxsync = 0;
    141       1.22    bouyer 	sc->st_minsync = 255;
    142       1.22    bouyer 	sc->dt_minsync = 255;
    143  1.46.10.2       jym 	for (i = 0; i < __arraycount(scf_period); i++) {
    144       1.22    bouyer 		if (sc->clock_period != scf_period[i].clock)
    145       1.22    bouyer 			continue;
    146       1.22    bouyer 		if (sc->st_maxsync < scf_period[i].period)
    147       1.22    bouyer 			sc->st_maxsync = scf_period[i].period;
    148       1.22    bouyer 		if (sc->st_minsync > scf_period[i].period)
    149       1.22    bouyer 			sc->st_minsync = scf_period[i].period;
    150       1.22    bouyer 	}
    151       1.22    bouyer 	if (sc->st_maxsync == 255 || sc->st_minsync == 0)
    152       1.31    provos 		panic("siop: can't find my sync parameters");
    153  1.46.10.2       jym 	for (i = 0; i < __arraycount(dt_scf_period); i++) {
    154       1.22    bouyer 		if (sc->clock_period != dt_scf_period[i].clock)
    155       1.22    bouyer 			continue;
    156       1.22    bouyer 		if (sc->dt_maxsync < dt_scf_period[i].period)
    157       1.22    bouyer 			sc->dt_maxsync = dt_scf_period[i].period;
    158       1.22    bouyer 		if (sc->dt_minsync > dt_scf_period[i].period)
    159       1.22    bouyer 			sc->dt_minsync = dt_scf_period[i].period;
    160       1.22    bouyer 	}
    161       1.22    bouyer 	if (sc->dt_maxsync == 255 || sc->dt_minsync == 0)
    162       1.31    provos 		panic("siop: can't find my sync parameters");
    163       1.22    bouyer 	return 0;
    164       1.22    bouyer }
    165        1.1    bouyer 
    166        1.1    bouyer void
    167  1.46.10.1       jym siop_common_reset(struct siop_common_softc *sc)
    168        1.1    bouyer {
    169       1.46  kiyohara 	u_int32_t stest1, stest3;
    170        1.1    bouyer 
    171        1.1    bouyer 	/* reset the chip */
    172        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_ISTAT, ISTAT_SRST);
    173        1.1    bouyer 	delay(1000);
    174        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_ISTAT, 0);
    175        1.1    bouyer 
    176        1.1    bouyer 	/* init registers */
    177        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL0,
    178        1.1    bouyer 	    SCNTL0_ARB_MASK | SCNTL0_EPC | SCNTL0_AAP);
    179        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1, 0);
    180        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL3, sc->clock_div);
    181        1.7    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SXFER, 0);
    182        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_DIEN, 0xff);
    183        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SIEN0,
    184        1.1    bouyer 	    0xff & ~(SIEN0_CMP | SIEN0_SEL | SIEN0_RSL));
    185        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SIEN1,
    186        1.1    bouyer 	    0xff & ~(SIEN1_HTH | SIEN1_GEN));
    187        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2, 0);
    188        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST3, STEST3_TE);
    189        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STIME0,
    190        1.1    bouyer 	    (0xb << STIME0_SEL_SHIFT));
    191        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCID,
    192       1.14    bouyer 	    sc->sc_chan.chan_id | SCID_RRE);
    193        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_RESPID0,
    194       1.14    bouyer 	    1 << sc->sc_chan.chan_id);
    195        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_DCNTL,
    196        1.1    bouyer 	    (sc->features & SF_CHIP_PF) ? DCNTL_COM | DCNTL_PFEN : DCNTL_COM);
    197       1.33    bouyer 	if (sc->features & SF_CHIP_AAIP)
    198       1.33    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh,
    199       1.33    bouyer 		    SIOP_AIPCNTL1, AIPCNTL1_DIS);
    200        1.1    bouyer 
    201        1.1    bouyer 	/* enable clock doubler or quadruler if appropriate */
    202        1.1    bouyer 	if (sc->features & (SF_CHIP_DBLR | SF_CHIP_QUAD)) {
    203        1.1    bouyer 		stest3 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_STEST3);
    204        1.1    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST1,
    205        1.1    bouyer 		    STEST1_DBLEN);
    206        1.1    bouyer 		if (sc->features & SF_CHIP_QUAD) {
    207        1.1    bouyer 			/* wait for PPL to lock */
    208        1.1    bouyer 			while ((bus_space_read_1(sc->sc_rt, sc->sc_rh,
    209        1.1    bouyer 			    SIOP_STEST4) & STEST4_LOCK) == 0)
    210        1.1    bouyer 				delay(10);
    211        1.1    bouyer 		} else {
    212        1.1    bouyer 			/* data sheet says 20us - more won't hurt */
    213        1.1    bouyer 			delay(100);
    214        1.1    bouyer 		}
    215        1.1    bouyer 		/* halt scsi clock, select doubler/quad, restart clock */
    216        1.1    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST3,
    217        1.1    bouyer 		    stest3 | STEST3_HSC);
    218        1.1    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST1,
    219        1.1    bouyer 		    STEST1_DBLEN | STEST1_DBLSEL);
    220        1.1    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST3, stest3);
    221        1.1    bouyer 	} else {
    222        1.1    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST1, 0);
    223        1.1    bouyer 	}
    224       1.46  kiyohara 
    225       1.46  kiyohara 	if (sc->features & SF_CHIP_USEPCIC) {
    226       1.46  kiyohara 		stest1 = bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_STEST1);
    227       1.46  kiyohara 		stest1 |= STEST1_SCLK;
    228       1.46  kiyohara 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST1, stest1);
    229       1.46  kiyohara 	}
    230       1.46  kiyohara 
    231        1.1    bouyer 	if (sc->features & SF_CHIP_FIFO)
    232        1.1    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST5,
    233        1.1    bouyer 		    bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST5) |
    234        1.1    bouyer 		    CTEST5_DFS);
    235       1.21    bouyer 	if (sc->features & SF_CHIP_LED0) {
    236       1.21    bouyer 		/* Set GPIO0 as output if software LED control is required */
    237       1.21    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_GPCNTL,
    238       1.21    bouyer 		    bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_GPCNTL) & 0xfe);
    239       1.21    bouyer 	}
    240       1.22    bouyer 	if (sc->features & SF_BUS_ULTRA3) {
    241       1.22    bouyer 		/* reset SCNTL4 */
    242       1.22    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL4, 0);
    243       1.22    bouyer 	}
    244       1.27    bouyer 	sc->mode = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_STEST4) &
    245       1.27    bouyer 	    STEST4_MODE_MASK;
    246       1.30    bouyer 
    247       1.30    bouyer 	/*
    248       1.30    bouyer 	 * initialise the RAM. Without this we may get scsi gross errors on
    249       1.30    bouyer 	 * the 1010
    250       1.30    bouyer 	 */
    251       1.30    bouyer 	if (sc->features & SF_CHIP_RAM)
    252       1.30    bouyer 		bus_space_set_region_4(sc->sc_ramt, sc->sc_ramh,
    253       1.30    bouyer 			0, 0, sc->ram_size / 4);
    254        1.1    bouyer 	sc->sc_reset(sc);
    255        1.1    bouyer }
    256        1.1    bouyer 
    257       1.10    bouyer /* prepare tables before sending a cmd */
    258       1.10    bouyer void
    259  1.46.10.1       jym siop_setuptables(struct siop_common_cmd *siop_cmd)
    260       1.10    bouyer {
    261       1.10    bouyer 	int i;
    262       1.17    bouyer 	struct siop_common_softc *sc = siop_cmd->siop_sc;
    263       1.10    bouyer 	struct scsipi_xfer *xs = siop_cmd->xs;
    264       1.14    bouyer 	int target = xs->xs_periph->periph_target;
    265       1.14    bouyer 	int lun = xs->xs_periph->periph_lun;
    266       1.14    bouyer 	int msgoffset = 1;
    267       1.10    bouyer 
    268       1.44     skrll 	siop_cmd->siop_tables->id = siop_htoc32(sc, sc->targets[target]->id);
    269       1.22    bouyer 	memset(siop_cmd->siop_tables->msg_out, 0,
    270       1.22    bouyer 	    sizeof(siop_cmd->siop_tables->msg_out));
    271       1.14    bouyer 	/* request sense doesn't disconnect */
    272       1.14    bouyer 	if (xs->xs_control & XS_CTL_REQSENSE)
    273       1.17    bouyer 		siop_cmd->siop_tables->msg_out[0] = MSG_IDENTIFY(lun, 0);
    274       1.26    bouyer 	else if ((sc->features & SF_CHIP_GEBUG) &&
    275       1.26    bouyer 	    (sc->targets[target]->flags & TARF_ISWIDE) == 0)
    276       1.26    bouyer 		/*
    277       1.26    bouyer 		 * 1010 bug: it seems that the 1010 has problems with reselect
    278       1.26    bouyer 		 * when not in wide mode (generate false SCSI gross error).
    279       1.26    bouyer 		 * The FreeBSD sym driver has comments about it but their
    280       1.26    bouyer 		 * workaround (disable SCSI gross error reporting) doesn't
    281       1.26    bouyer 		 * work with my adapter. So disable disconnect when not
    282       1.26    bouyer 		 * wide.
    283       1.26    bouyer 		 */
    284       1.26    bouyer 		siop_cmd->siop_tables->msg_out[0] = MSG_IDENTIFY(lun, 0);
    285       1.14    bouyer 	else
    286       1.17    bouyer 		siop_cmd->siop_tables->msg_out[0] = MSG_IDENTIFY(lun, 1);
    287       1.14    bouyer 	if (xs->xs_tag_type != 0) {
    288       1.14    bouyer 		if ((sc->targets[target]->flags & TARF_TAG) == 0) {
    289       1.14    bouyer 			scsipi_printaddr(xs->xs_periph);
    290       1.14    bouyer 			printf(": tagged command type %d id %d\n",
    291       1.14    bouyer 			    siop_cmd->xs->xs_tag_type, siop_cmd->xs->xs_tag_id);
    292       1.31    provos 			panic("tagged command for non-tagging device");
    293       1.14    bouyer 		}
    294       1.14    bouyer 		siop_cmd->flags |= CMDFL_TAG;
    295       1.17    bouyer 		siop_cmd->siop_tables->msg_out[1] = siop_cmd->xs->xs_tag_type;
    296       1.19    bouyer 		/*
    297       1.19    bouyer 		 * use siop_cmd->tag not xs->xs_tag_id, caller may want a
    298       1.19    bouyer 		 * different one
    299       1.19    bouyer 		 */
    300       1.19    bouyer 		siop_cmd->siop_tables->msg_out[2] = siop_cmd->tag;
    301       1.14    bouyer 		msgoffset = 3;
    302       1.20    bouyer 	}
    303       1.44     skrll 	siop_cmd->siop_tables->t_msgout.count = siop_htoc32(sc, msgoffset);
    304       1.10    bouyer 	if (sc->targets[target]->status == TARST_ASYNC) {
    305       1.27    bouyer 		if ((sc->targets[target]->flags & TARF_DT) &&
    306  1.46.10.2       jym 		    (sc->mode == STEST4_MODE_LVD)) {
    307       1.22    bouyer 			sc->targets[target]->status = TARST_PPR_NEG;
    308  1.46.10.2       jym 			siop_ppr_msg(siop_cmd, msgoffset, sc->dt_minsync,
    309       1.22    bouyer 			    sc->maxoff);
    310       1.22    bouyer 		} else if (sc->targets[target]->flags & TARF_WIDE) {
    311       1.10    bouyer 			sc->targets[target]->status = TARST_WIDE_NEG;
    312       1.14    bouyer 			siop_wdtr_msg(siop_cmd, msgoffset,
    313       1.14    bouyer 			    MSG_EXT_WDTR_BUS_16_BIT);
    314       1.10    bouyer 		} else if (sc->targets[target]->flags & TARF_SYNC) {
    315       1.10    bouyer 			sc->targets[target]->status = TARST_SYNC_NEG;
    316       1.22    bouyer 			siop_sdtr_msg(siop_cmd, msgoffset, sc->st_minsync,
    317       1.22    bouyer 			(sc->maxoff > 31) ? 31 :  sc->maxoff);
    318       1.10    bouyer 		} else {
    319       1.10    bouyer 			sc->targets[target]->status = TARST_OK;
    320       1.14    bouyer 			siop_update_xfer_mode(sc, target);
    321       1.10    bouyer 		}
    322       1.10    bouyer 	}
    323       1.17    bouyer 	siop_cmd->siop_tables->status =
    324       1.44     skrll 	    siop_htoc32(sc, SCSI_SIOP_NOSTATUS); /* set invalid status */
    325       1.10    bouyer 
    326       1.17    bouyer 	siop_cmd->siop_tables->cmd.count =
    327       1.44     skrll 	    siop_htoc32(sc, siop_cmd->dmamap_cmd->dm_segs[0].ds_len);
    328       1.17    bouyer 	siop_cmd->siop_tables->cmd.addr =
    329       1.44     skrll 	    siop_htoc32(sc, siop_cmd->dmamap_cmd->dm_segs[0].ds_addr);
    330       1.14    bouyer 	if (xs->xs_control & (XS_CTL_DATA_IN | XS_CTL_DATA_OUT)) {
    331       1.10    bouyer 		for (i = 0; i < siop_cmd->dmamap_data->dm_nsegs; i++) {
    332       1.17    bouyer 			siop_cmd->siop_tables->data[i].count =
    333       1.44     skrll 			    siop_htoc32(sc,
    334       1.44     skrll 				siop_cmd->dmamap_data->dm_segs[i].ds_len);
    335       1.17    bouyer 			siop_cmd->siop_tables->data[i].addr =
    336       1.44     skrll 			    siop_htoc32(sc,
    337       1.44     skrll 				siop_cmd->dmamap_data->dm_segs[i].ds_addr);
    338       1.10    bouyer 		}
    339       1.10    bouyer 	}
    340       1.10    bouyer }
    341       1.10    bouyer 
    342        1.1    bouyer int
    343  1.46.10.1       jym siop_wdtr_neg(struct siop_common_cmd *siop_cmd)
    344        1.1    bouyer {
    345       1.17    bouyer 	struct siop_common_softc *sc = siop_cmd->siop_sc;
    346       1.17    bouyer 	struct siop_common_target *siop_target = siop_cmd->siop_target;
    347       1.14    bouyer 	int target = siop_cmd->xs->xs_periph->periph_target;
    348       1.17    bouyer 	struct siop_common_xfer *tables = siop_cmd->siop_tables;
    349        1.1    bouyer 
    350        1.1    bouyer 	if (siop_target->status == TARST_WIDE_NEG) {
    351        1.1    bouyer 		/* we initiated wide negotiation */
    352        1.9    bouyer 		switch (tables->msg_in[3]) {
    353        1.1    bouyer 		case MSG_EXT_WDTR_BUS_8_BIT:
    354        1.9    bouyer 			siop_target->flags &= ~TARF_ISWIDE;
    355        1.1    bouyer 			sc->targets[target]->id &= ~(SCNTL3_EWS << 24);
    356        1.1    bouyer 			break;
    357        1.1    bouyer 		case MSG_EXT_WDTR_BUS_16_BIT:
    358        1.9    bouyer 			if (siop_target->flags & TARF_WIDE) {
    359        1.9    bouyer 				siop_target->flags |= TARF_ISWIDE;
    360        1.1    bouyer 				sc->targets[target]->id |= (SCNTL3_EWS << 24);
    361        1.1    bouyer 				break;
    362        1.1    bouyer 			}
    363       1.38   tsutsui 		/* FALLTHROUGH */
    364        1.1    bouyer 		default:
    365        1.1    bouyer 			/*
    366       1.29       wiz  			 * hum, we got more than what we can handle, shouldn't
    367        1.1    bouyer 			 * happen. Reject, and stay async
    368        1.1    bouyer 			 */
    369        1.9    bouyer 			siop_target->flags &= ~TARF_ISWIDE;
    370        1.1    bouyer 			siop_target->status = TARST_OK;
    371       1.14    bouyer 			siop_target->offset = siop_target->period = 0;
    372       1.14    bouyer 			siop_update_xfer_mode(sc, target);
    373        1.1    bouyer 			printf("%s: rejecting invalid wide negotiation from "
    374  1.46.10.2       jym 			    "target %d (%d)\n", device_xname(sc->sc_dev),
    375  1.46.10.2       jym 			    target,
    376        1.9    bouyer 			    tables->msg_in[3]);
    377       1.44     skrll 			tables->t_msgout.count = siop_htoc32(sc, 1);
    378        1.9    bouyer 			tables->msg_out[0] = MSG_MESSAGE_REJECT;
    379        1.1    bouyer 			return SIOP_NEG_MSGOUT;
    380        1.1    bouyer 		}
    381       1.44     skrll 		tables->id = siop_htoc32(sc, sc->targets[target]->id);
    382        1.1    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh,
    383        1.1    bouyer 		    SIOP_SCNTL3,
    384        1.1    bouyer 		    (sc->targets[target]->id >> 24) & 0xff);
    385        1.1    bouyer 		/* we now need to do sync */
    386        1.9    bouyer 		if (siop_target->flags & TARF_SYNC) {
    387        1.6    bouyer 			siop_target->status = TARST_SYNC_NEG;
    388       1.22    bouyer 			siop_sdtr_msg(siop_cmd, 0, sc->st_minsync,
    389       1.22    bouyer 			    (sc->maxoff > 31) ? 31 : sc->maxoff);
    390        1.6    bouyer 			return SIOP_NEG_MSGOUT;
    391        1.6    bouyer 		} else {
    392        1.6    bouyer 			siop_target->status = TARST_OK;
    393       1.14    bouyer 			siop_update_xfer_mode(sc, target);
    394        1.6    bouyer 			return SIOP_NEG_ACK;
    395        1.6    bouyer 		}
    396        1.1    bouyer 	} else {
    397        1.1    bouyer 		/* target initiated wide negotiation */
    398        1.9    bouyer 		if (tables->msg_in[3] >= MSG_EXT_WDTR_BUS_16_BIT
    399        1.9    bouyer 		    && (siop_target->flags & TARF_WIDE)) {
    400        1.9    bouyer 			siop_target->flags |= TARF_ISWIDE;
    401        1.1    bouyer 			sc->targets[target]->id |= SCNTL3_EWS << 24;
    402        1.1    bouyer 		} else {
    403        1.9    bouyer 			siop_target->flags &= ~TARF_ISWIDE;
    404        1.1    bouyer 			sc->targets[target]->id &= ~(SCNTL3_EWS << 24);
    405        1.1    bouyer 		}
    406       1.44     skrll 		tables->id = siop_htoc32(sc, sc->targets[target]->id);
    407        1.1    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL3,
    408        1.1    bouyer 		    (sc->targets[target]->id >> 24) & 0xff);
    409        1.1    bouyer 		/*
    410        1.1    bouyer 		 * we did reset wide parameters, so fall back to async,
    411        1.8    bouyer 		 * but don't schedule a sync neg, target should initiate it
    412        1.1    bouyer 		 */
    413        1.1    bouyer 		siop_target->status = TARST_OK;
    414       1.14    bouyer 		siop_target->offset = siop_target->period = 0;
    415       1.14    bouyer 		siop_update_xfer_mode(sc, target);
    416       1.10    bouyer 		siop_wdtr_msg(siop_cmd, 0, (siop_target->flags & TARF_ISWIDE) ?
    417       1.10    bouyer 		    MSG_EXT_WDTR_BUS_16_BIT : MSG_EXT_WDTR_BUS_8_BIT);
    418        1.1    bouyer 		return SIOP_NEG_MSGOUT;
    419        1.1    bouyer 	}
    420        1.1    bouyer }
    421        1.1    bouyer 
    422        1.1    bouyer int
    423  1.46.10.1       jym siop_ppr_neg(struct siop_common_cmd *siop_cmd)
    424       1.22    bouyer {
    425       1.22    bouyer 	struct siop_common_softc *sc = siop_cmd->siop_sc;
    426       1.22    bouyer 	struct siop_common_target *siop_target = siop_cmd->siop_target;
    427       1.22    bouyer 	int target = siop_cmd->xs->xs_periph->periph_target;
    428       1.22    bouyer 	struct siop_common_xfer *tables = siop_cmd->siop_tables;
    429       1.22    bouyer 	int sync, offset, options, scf = 0;
    430       1.22    bouyer 	int i;
    431       1.22    bouyer 
    432       1.22    bouyer #ifdef DEBUG_NEG
    433  1.46.10.2       jym 	printf("%s: answer on ppr negotiation:", device_xname(sc->sc_dev));
    434       1.22    bouyer 	for (i = 0; i < 8; i++)
    435       1.22    bouyer 		printf(" 0x%x", tables->msg_in[i]);
    436       1.22    bouyer 	printf("\n");
    437       1.22    bouyer #endif
    438       1.22    bouyer 
    439       1.22    bouyer 	if (siop_target->status == TARST_PPR_NEG) {
    440       1.22    bouyer 		/* we initiated PPR negotiation */
    441       1.22    bouyer 		sync = tables->msg_in[3];
    442       1.22    bouyer 		offset = tables->msg_in[5];
    443       1.22    bouyer 		options = tables->msg_in[7];
    444       1.22    bouyer 		if (options != MSG_EXT_PPR_DT) {
    445       1.22    bouyer 			/* should't happen */
    446       1.22    bouyer 			printf("%s: ppr negotiation for target %d: "
    447  1.46.10.2       jym 			    "no DT option\n", device_xname(sc->sc_dev), target);
    448       1.22    bouyer 			siop_target->status = TARST_ASYNC;
    449       1.22    bouyer 			siop_target->flags &= ~(TARF_DT | TARF_ISDT);
    450       1.22    bouyer 			siop_target->offset = 0;
    451       1.22    bouyer 			siop_target->period = 0;
    452       1.22    bouyer 			goto reject;
    453       1.22    bouyer 		}
    454       1.37     perry 
    455       1.22    bouyer 		if (offset > sc->maxoff || sync < sc->dt_minsync ||
    456       1.22    bouyer 		    sync > sc->dt_maxsync) {
    457       1.22    bouyer 			printf("%s: ppr negotiation for target %d: "
    458       1.22    bouyer 			    "offset (%d) or sync (%d) out of range\n",
    459  1.46.10.2       jym 			    device_xname(sc->sc_dev), target, offset, sync);
    460       1.22    bouyer 			/* should not happen */
    461       1.22    bouyer 			siop_target->offset = 0;
    462       1.22    bouyer 			siop_target->period = 0;
    463       1.22    bouyer 			goto reject;
    464       1.22    bouyer 		} else {
    465  1.46.10.2       jym 			for (i = 0; i < __arraycount(dt_scf_period); i++) {
    466       1.22    bouyer 				if (sc->clock_period != dt_scf_period[i].clock)
    467       1.22    bouyer 					continue;
    468       1.22    bouyer 				if (dt_scf_period[i].period == sync) {
    469       1.22    bouyer 					/* ok, found it. we now are sync. */
    470       1.22    bouyer 					siop_target->offset = offset;
    471       1.22    bouyer 					siop_target->period = sync;
    472       1.22    bouyer 					scf = dt_scf_period[i].scf;
    473       1.22    bouyer 					siop_target->flags |= TARF_ISDT;
    474       1.22    bouyer 				}
    475       1.22    bouyer 			}
    476       1.22    bouyer 			if ((siop_target->flags & TARF_ISDT) == 0) {
    477       1.22    bouyer 				printf("%s: ppr negotiation for target %d: "
    478       1.22    bouyer 				    "sync (%d) incompatible with adapter\n",
    479  1.46.10.2       jym 				    device_xname(sc->sc_dev), target, sync);
    480       1.22    bouyer 				/*
    481       1.22    bouyer 				 * we didn't find it in our table, do async
    482       1.22    bouyer 				 * send reject msg, start SDTR/WDTR neg
    483       1.22    bouyer 				 */
    484       1.22    bouyer 				siop_target->status = TARST_ASYNC;
    485       1.22    bouyer 				siop_target->flags &= ~(TARF_DT | TARF_ISDT);
    486       1.22    bouyer 				siop_target->offset = 0;
    487       1.22    bouyer 				siop_target->period = 0;
    488       1.22    bouyer 				goto reject;
    489       1.22    bouyer 			}
    490       1.22    bouyer 		}
    491       1.22    bouyer 		if (tables->msg_in[6] != 1) {
    492       1.22    bouyer 			printf("%s: ppr negotiation for target %d: "
    493       1.22    bouyer 			    "transfer width (%d) incompatible with dt\n",
    494  1.46.10.2       jym 			    device_xname(sc->sc_dev),
    495  1.46.10.2       jym 			    target, tables->msg_in[6]);
    496       1.22    bouyer 			/* DT mode can only be done with wide transfers */
    497       1.22    bouyer 			siop_target->status = TARST_ASYNC;
    498       1.22    bouyer 			goto reject;
    499       1.37     perry 		}
    500       1.22    bouyer 		siop_target->flags |= TARF_ISWIDE;
    501       1.22    bouyer 		sc->targets[target]->id |= (SCNTL3_EWS << 24);
    502       1.22    bouyer 		sc->targets[target]->id &= ~(SCNTL3_SCF_MASK << 24);
    503       1.22    bouyer 		sc->targets[target]->id |= scf << (24 + SCNTL3_SCF_SHIFT);
    504       1.22    bouyer 		sc->targets[target]->id &= ~(SXFER_MO_MASK << 8);
    505       1.22    bouyer 		sc->targets[target]->id |=
    506       1.22    bouyer 		    (siop_target->offset & SXFER_MO_MASK) << 8;
    507       1.22    bouyer 		sc->targets[target]->id &= ~0xff;
    508       1.22    bouyer 		sc->targets[target]->id |= SCNTL4_U3EN;
    509       1.22    bouyer 		siop_target->status = TARST_OK;
    510       1.22    bouyer 		siop_update_xfer_mode(sc, target);
    511       1.22    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL3,
    512       1.22    bouyer 		    (sc->targets[target]->id >> 24) & 0xff);
    513       1.22    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SXFER,
    514       1.22    bouyer 		    (sc->targets[target]->id >> 8) & 0xff);
    515       1.22    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL4,
    516       1.22    bouyer 		    sc->targets[target]->id & 0xff);
    517       1.22    bouyer 		return SIOP_NEG_ACK;
    518       1.22    bouyer 	} else {
    519       1.22    bouyer 		/* target initiated PPR negotiation, shouldn't happen */
    520       1.22    bouyer 		printf("%s: rejecting invalid PPR negotiation from "
    521  1.46.10.2       jym 		    "target %d\n", device_xname(sc->sc_dev), target);
    522       1.22    bouyer reject:
    523       1.44     skrll 		tables->t_msgout.count = siop_htoc32(sc, 1);
    524       1.22    bouyer 		tables->msg_out[0] = MSG_MESSAGE_REJECT;
    525       1.22    bouyer 		return SIOP_NEG_MSGOUT;
    526       1.22    bouyer 	}
    527       1.22    bouyer }
    528       1.22    bouyer 
    529       1.22    bouyer int
    530  1.46.10.1       jym siop_sdtr_neg(struct siop_common_cmd *siop_cmd)
    531        1.1    bouyer {
    532       1.17    bouyer 	struct siop_common_softc *sc = siop_cmd->siop_sc;
    533       1.17    bouyer 	struct siop_common_target *siop_target = siop_cmd->siop_target;
    534       1.14    bouyer 	int target = siop_cmd->xs->xs_periph->periph_target;
    535       1.22    bouyer 	int sync, maxoffset, offset, i;
    536        1.1    bouyer 	int send_msgout = 0;
    537       1.17    bouyer 	struct siop_common_xfer *tables = siop_cmd->siop_tables;
    538        1.1    bouyer 
    539       1.22    bouyer 	/* limit to Ultra/2 parameters, need PPR for Ultra/3 */
    540       1.22    bouyer 	maxoffset = (sc->maxoff > 31) ? 31 : sc->maxoff;
    541       1.22    bouyer 
    542        1.9    bouyer 	sync = tables->msg_in[3];
    543        1.9    bouyer 	offset = tables->msg_in[4];
    544        1.1    bouyer 
    545        1.1    bouyer 	if (siop_target->status == TARST_SYNC_NEG) {
    546        1.1    bouyer 		/* we initiated sync negotiation */
    547        1.1    bouyer 		siop_target->status = TARST_OK;
    548        1.1    bouyer #ifdef DEBUG
    549        1.1    bouyer 		printf("sdtr: sync %d offset %d\n", sync, offset);
    550        1.1    bouyer #endif
    551       1.22    bouyer 		if (offset > maxoffset || sync < sc->st_minsync ||
    552       1.22    bouyer 			sync > sc->st_maxsync)
    553        1.1    bouyer 			goto reject;
    554  1.46.10.2       jym 		for (i = 0; i < __arraycount(scf_period); i++) {
    555        1.1    bouyer 			if (sc->clock_period != scf_period[i].clock)
    556        1.1    bouyer 				continue;
    557        1.1    bouyer 			if (scf_period[i].period == sync) {
    558        1.1    bouyer 				/* ok, found it. we now are sync. */
    559       1.14    bouyer 				siop_target->offset = offset;
    560       1.14    bouyer 				siop_target->period = sync;
    561        1.1    bouyer 				sc->targets[target]->id &=
    562        1.1    bouyer 				    ~(SCNTL3_SCF_MASK << 24);
    563        1.1    bouyer 				sc->targets[target]->id |= scf_period[i].scf
    564        1.1    bouyer 				    << (24 + SCNTL3_SCF_SHIFT);
    565       1.22    bouyer 				if (sync < 25 && /* Ultra */
    566       1.22    bouyer 				    (sc->features & SF_BUS_ULTRA3) == 0)
    567        1.1    bouyer 					sc->targets[target]->id |=
    568        1.1    bouyer 					    SCNTL3_ULTRA << 24;
    569        1.1    bouyer 				else
    570        1.1    bouyer 					sc->targets[target]->id &=
    571        1.1    bouyer 					    ~(SCNTL3_ULTRA << 24);
    572        1.1    bouyer 				sc->targets[target]->id &=
    573        1.7    bouyer 				    ~(SXFER_MO_MASK << 8);
    574        1.1    bouyer 				sc->targets[target]->id |=
    575        1.7    bouyer 				    (offset & SXFER_MO_MASK) << 8;
    576       1.25    bouyer 				sc->targets[target]->id &= ~0xff; /* scntl4 */
    577        1.1    bouyer 				goto end;
    578        1.1    bouyer 			}
    579        1.1    bouyer 		}
    580        1.1    bouyer 		/*
    581        1.1    bouyer 		 * we didn't find it in our table, do async and send reject
    582        1.1    bouyer 		 * msg
    583        1.1    bouyer 		 */
    584        1.1    bouyer reject:
    585        1.1    bouyer 		send_msgout = 1;
    586       1.44     skrll 		tables->t_msgout.count = siop_htoc32(sc, 1);
    587        1.9    bouyer 		tables->msg_out[0] = MSG_MESSAGE_REJECT;
    588        1.1    bouyer 		sc->targets[target]->id &= ~(SCNTL3_SCF_MASK << 24);
    589        1.1    bouyer 		sc->targets[target]->id &= ~(SCNTL3_ULTRA << 24);
    590        1.7    bouyer 		sc->targets[target]->id &= ~(SXFER_MO_MASK << 8);
    591       1.25    bouyer 		sc->targets[target]->id &= ~0xff; /* scntl4 */
    592       1.14    bouyer 		siop_target->offset = siop_target->period = 0;
    593        1.1    bouyer 	} else { /* target initiated sync neg */
    594        1.1    bouyer #ifdef DEBUG
    595        1.1    bouyer 		printf("sdtr (target): sync %d offset %d\n", sync, offset);
    596        1.1    bouyer #endif
    597       1.22    bouyer 		if (offset == 0 || sync > sc->st_maxsync) { /* async */
    598        1.1    bouyer 			goto async;
    599        1.1    bouyer 		}
    600       1.22    bouyer 		if (offset > maxoffset)
    601       1.22    bouyer 			offset = maxoffset;
    602       1.22    bouyer 		if (sync < sc->st_minsync)
    603       1.22    bouyer 			sync = sc->st_minsync;
    604        1.1    bouyer 		/* look for sync period */
    605  1.46.10.2       jym 		for (i = 0; i < __arraycount(scf_period); i++) {
    606        1.1    bouyer 			if (sc->clock_period != scf_period[i].clock)
    607        1.1    bouyer 				continue;
    608        1.1    bouyer 			if (scf_period[i].period == sync) {
    609        1.1    bouyer 				/* ok, found it. we now are sync. */
    610       1.14    bouyer 				siop_target->offset = offset;
    611       1.14    bouyer 				siop_target->period = sync;
    612        1.1    bouyer 				sc->targets[target]->id &=
    613        1.1    bouyer 				    ~(SCNTL3_SCF_MASK << 24);
    614        1.1    bouyer 				sc->targets[target]->id |= scf_period[i].scf
    615        1.1    bouyer 				    << (24 + SCNTL3_SCF_SHIFT);
    616       1.22    bouyer 				if (sync < 25 && /* Ultra */
    617       1.22    bouyer 				    (sc->features & SF_BUS_ULTRA3) == 0)
    618        1.1    bouyer 					sc->targets[target]->id |=
    619        1.1    bouyer 					    SCNTL3_ULTRA << 24;
    620        1.1    bouyer 				else
    621        1.1    bouyer 					sc->targets[target]->id &=
    622        1.1    bouyer 					    ~(SCNTL3_ULTRA << 24);
    623        1.1    bouyer 				sc->targets[target]->id &=
    624        1.7    bouyer 				    ~(SXFER_MO_MASK << 8);
    625        1.1    bouyer 				sc->targets[target]->id |=
    626        1.7    bouyer 				    (offset & SXFER_MO_MASK) << 8;
    627       1.25    bouyer 				sc->targets[target]->id &= ~0xff; /* scntl4 */
    628       1.10    bouyer 				siop_sdtr_msg(siop_cmd, 0, sync, offset);
    629        1.1    bouyer 				send_msgout = 1;
    630        1.1    bouyer 				goto end;
    631        1.1    bouyer 			}
    632        1.1    bouyer 		}
    633        1.1    bouyer async:
    634       1.14    bouyer 		siop_target->offset = siop_target->period = 0;
    635        1.1    bouyer 		sc->targets[target]->id &= ~(SCNTL3_SCF_MASK << 24);
    636        1.1    bouyer 		sc->targets[target]->id &= ~(SCNTL3_ULTRA << 24);
    637        1.7    bouyer 		sc->targets[target]->id &= ~(SXFER_MO_MASK << 8);
    638       1.25    bouyer 		sc->targets[target]->id &= ~0xff; /* scntl4 */
    639       1.10    bouyer 		siop_sdtr_msg(siop_cmd, 0, 0, 0);
    640        1.1    bouyer 		send_msgout = 1;
    641        1.1    bouyer 	}
    642        1.1    bouyer end:
    643       1.14    bouyer 	if (siop_target->status == TARST_OK)
    644       1.14    bouyer 		siop_update_xfer_mode(sc, target);
    645        1.1    bouyer #ifdef DEBUG
    646        1.1    bouyer 	printf("id now 0x%x\n", sc->targets[target]->id);
    647        1.1    bouyer #endif
    648       1.44     skrll 	tables->id = siop_htoc32(sc, sc->targets[target]->id);
    649        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL3,
    650        1.1    bouyer 	    (sc->targets[target]->id >> 24) & 0xff);
    651        1.7    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SXFER,
    652        1.1    bouyer 	    (sc->targets[target]->id >> 8) & 0xff);
    653        1.1    bouyer 	if (send_msgout) {
    654        1.1    bouyer 		return SIOP_NEG_MSGOUT;
    655        1.1    bouyer 	} else {
    656        1.1    bouyer 		return SIOP_NEG_ACK;
    657        1.1    bouyer 	}
    658        1.1    bouyer }
    659        1.1    bouyer 
    660        1.1    bouyer void
    661  1.46.10.1       jym siop_sdtr_msg(struct siop_common_cmd *siop_cmd, int offset, int ssync, int soff)
    662       1.10    bouyer {
    663  1.46.10.2       jym 
    664       1.17    bouyer 	siop_cmd->siop_tables->msg_out[offset + 0] = MSG_EXTENDED;
    665       1.17    bouyer 	siop_cmd->siop_tables->msg_out[offset + 1] = MSG_EXT_SDTR_LEN;
    666       1.17    bouyer 	siop_cmd->siop_tables->msg_out[offset + 2] = MSG_EXT_SDTR;
    667       1.17    bouyer 	siop_cmd->siop_tables->msg_out[offset + 3] = ssync;
    668       1.17    bouyer 	siop_cmd->siop_tables->msg_out[offset + 4] = soff;
    669       1.17    bouyer 	siop_cmd->siop_tables->t_msgout.count =
    670       1.44     skrll 	    siop_htoc32(siop_cmd->siop_sc, offset + MSG_EXT_SDTR_LEN + 2);
    671       1.10    bouyer }
    672       1.10    bouyer 
    673       1.10    bouyer void
    674  1.46.10.1       jym siop_wdtr_msg(struct siop_common_cmd *siop_cmd, int offset, int wide)
    675       1.10    bouyer {
    676  1.46.10.2       jym 
    677       1.17    bouyer 	siop_cmd->siop_tables->msg_out[offset + 0] = MSG_EXTENDED;
    678       1.17    bouyer 	siop_cmd->siop_tables->msg_out[offset + 1] = MSG_EXT_WDTR_LEN;
    679       1.17    bouyer 	siop_cmd->siop_tables->msg_out[offset + 2] = MSG_EXT_WDTR;
    680       1.17    bouyer 	siop_cmd->siop_tables->msg_out[offset + 3] = wide;
    681       1.17    bouyer 	siop_cmd->siop_tables->t_msgout.count =
    682       1.44     skrll 	    siop_htoc32(siop_cmd->siop_sc, offset + MSG_EXT_WDTR_LEN + 2);
    683       1.22    bouyer }
    684       1.22    bouyer 
    685       1.22    bouyer void
    686  1.46.10.1       jym siop_ppr_msg(struct siop_common_cmd *siop_cmd, int offset, int ssync, int soff)
    687       1.22    bouyer {
    688  1.46.10.2       jym 
    689       1.22    bouyer 	siop_cmd->siop_tables->msg_out[offset + 0] = MSG_EXTENDED;
    690       1.22    bouyer 	siop_cmd->siop_tables->msg_out[offset + 1] = MSG_EXT_PPR_LEN;
    691       1.22    bouyer 	siop_cmd->siop_tables->msg_out[offset + 2] = MSG_EXT_PPR;
    692       1.22    bouyer 	siop_cmd->siop_tables->msg_out[offset + 3] = ssync;
    693       1.22    bouyer 	siop_cmd->siop_tables->msg_out[offset + 4] = 0; /* reserved */
    694       1.22    bouyer 	siop_cmd->siop_tables->msg_out[offset + 5] = soff;
    695       1.22    bouyer 	siop_cmd->siop_tables->msg_out[offset + 6] = 1; /* wide */
    696       1.22    bouyer 	siop_cmd->siop_tables->msg_out[offset + 7] = MSG_EXT_PPR_DT;
    697       1.22    bouyer 	siop_cmd->siop_tables->t_msgout.count =
    698       1.44     skrll 	    siop_htoc32(siop_cmd->siop_sc, offset + MSG_EXT_PPR_LEN + 2);
    699       1.10    bouyer }
    700       1.10    bouyer 
    701       1.10    bouyer void
    702  1.46.10.1       jym siop_minphys(struct buf *bp)
    703        1.1    bouyer {
    704  1.46.10.2       jym 
    705        1.1    bouyer 	minphys(bp);
    706        1.1    bouyer }
    707        1.1    bouyer 
    708        1.1    bouyer int
    709       1.42  christos siop_ioctl(struct scsipi_channel *chan, u_long cmd, void *arg,
    710       1.41  christos     int flag, struct proc *p)
    711        1.1    bouyer {
    712  1.46.10.2       jym 	struct siop_common_softc *sc;
    713  1.46.10.2       jym 
    714  1.46.10.2       jym 	sc = device_private(chan->chan_adapter->adapt_dev);
    715        1.1    bouyer 
    716        1.1    bouyer 	switch (cmd) {
    717        1.1    bouyer 	case SCBUSIORESET:
    718       1.24    bouyer 		/*
    719       1.24    bouyer 		 * abort the script. This will trigger an interrupt, which will
    720       1.24    bouyer 		 * trigger a bus reset.
    721       1.24    bouyer 		 * We can't safely trigger the reset here as we can't access
    722       1.24    bouyer 		 * the required register while the script is running.
    723       1.24    bouyer 		 */
    724       1.24    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_ISTAT, ISTAT_ABRT);
    725        1.1    bouyer 		return (0);
    726        1.1    bouyer 	default:
    727        1.1    bouyer 		return (ENOTTY);
    728        1.1    bouyer 	}
    729        1.1    bouyer }
    730        1.1    bouyer 
    731        1.1    bouyer void
    732  1.46.10.1       jym siop_ma(struct siop_common_cmd *siop_cmd)
    733        1.1    bouyer {
    734        1.1    bouyer 	int offset, dbc, sstat;
    735       1.17    bouyer 	struct siop_common_softc *sc = siop_cmd->siop_sc;
    736       1.35    bouyer 	scr_table_t *table; /* table with partial xfer */
    737        1.1    bouyer 
    738       1.35    bouyer 	/*
    739       1.35    bouyer 	 * compute how much of the current table didn't get handled when
    740       1.35    bouyer 	 * a phase mismatch occurs
    741       1.35    bouyer 	 */
    742        1.1    bouyer 	if ((siop_cmd->xs->xs_control & (XS_CTL_DATA_OUT | XS_CTL_DATA_IN))
    743        1.1    bouyer 	    == 0)
    744       1.35    bouyer 	    return; /* no valid data transfer */
    745       1.35    bouyer 
    746        1.1    bouyer 	offset = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SCRATCHA + 1);
    747        1.1    bouyer 	if (offset >= SIOP_NSG) {
    748  1.46.10.2       jym 		aprint_error_dev(sc->sc_dev, "bad offset in siop_sdp (%d)\n",
    749       1.45    cegger 		    offset);
    750        1.1    bouyer 		return;
    751        1.1    bouyer 	}
    752       1.17    bouyer 	table = &siop_cmd->siop_tables->data[offset];
    753        1.1    bouyer #ifdef DEBUG_DR
    754       1.35    bouyer 	printf("siop_ma: offset %d count=%d addr=0x%x ", offset,
    755        1.1    bouyer 	    table->count, table->addr);
    756        1.1    bouyer #endif
    757        1.1    bouyer 	dbc = bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_DBC) & 0x00ffffff;
    758        1.1    bouyer 	if (siop_cmd->xs->xs_control & XS_CTL_DATA_OUT) {
    759       1.13    bouyer 		if (sc->features & SF_CHIP_DFBC) {
    760       1.13    bouyer 			dbc +=
    761       1.13    bouyer 			    bus_space_read_2(sc->sc_rt, sc->sc_rh, SIOP_DFBC);
    762        1.1    bouyer 		} else {
    763       1.13    bouyer 			/* need to account stale data in FIFO */
    764       1.13    bouyer 			int dfifo =
    765       1.13    bouyer 			    bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_DFIFO);
    766       1.13    bouyer 			if (sc->features & SF_CHIP_FIFO) {
    767       1.13    bouyer 				dfifo |= (bus_space_read_1(sc->sc_rt, sc->sc_rh,
    768       1.13    bouyer 				    SIOP_CTEST5) & CTEST5_BOMASK) << 8;
    769       1.13    bouyer 				dbc += (dfifo - (dbc & 0x3ff)) & 0x3ff;
    770       1.13    bouyer 			} else {
    771       1.13    bouyer 				dbc += (dfifo - (dbc & 0x7f)) & 0x7f;
    772       1.13    bouyer 			}
    773        1.1    bouyer 		}
    774        1.1    bouyer 		sstat = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SSTAT0);
    775        1.1    bouyer 		if (sstat & SSTAT0_OLF)
    776        1.1    bouyer 			dbc++;
    777       1.13    bouyer 		if ((sstat & SSTAT0_ORF) && (sc->features & SF_CHIP_DFBC) == 0)
    778        1.1    bouyer 			dbc++;
    779        1.9    bouyer 		if (siop_cmd->siop_target->flags & TARF_ISWIDE) {
    780        1.1    bouyer 			sstat = bus_space_read_1(sc->sc_rt, sc->sc_rh,
    781        1.1    bouyer 			    SIOP_SSTAT2);
    782        1.1    bouyer 			if (sstat & SSTAT2_OLF1)
    783        1.1    bouyer 				dbc++;
    784       1.13    bouyer 			if ((sstat & SSTAT2_ORF1) &&
    785       1.13    bouyer 			    (sc->features & SF_CHIP_DFBC) == 0)
    786        1.1    bouyer 				dbc++;
    787        1.1    bouyer 		}
    788        1.1    bouyer 		/* clear the FIFO */
    789        1.1    bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3,
    790        1.1    bouyer 		    bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3) |
    791        1.1    bouyer 		    CTEST3_CLF);
    792        1.1    bouyer 	}
    793       1.35    bouyer 	siop_cmd->flags |= CMDFL_RESID;
    794       1.35    bouyer 	siop_cmd->resid = dbc;
    795       1.35    bouyer }
    796       1.35    bouyer 
    797       1.35    bouyer void
    798  1.46.10.1       jym siop_sdp(struct siop_common_cmd *siop_cmd, int offset)
    799       1.35    bouyer {
    800       1.44     skrll 	struct siop_common_softc *sc = siop_cmd->siop_sc;
    801       1.35    bouyer 	scr_table_t *table;
    802       1.37     perry 
    803       1.35    bouyer 	if ((siop_cmd->xs->xs_control & (XS_CTL_DATA_OUT | XS_CTL_DATA_IN))
    804       1.35    bouyer 	    == 0)
    805       1.35    bouyer 	    return; /* no data pointers to save */
    806       1.35    bouyer 
    807       1.35    bouyer 	/*
    808       1.35    bouyer 	 * offset == SIOP_NSG may be a valid condition if we get a Save data
    809       1.35    bouyer 	 * pointer when the xfer is done. Just ignore the Save data pointer
    810       1.35    bouyer 	 * in this case
    811       1.35    bouyer 	 */
    812       1.35    bouyer 	if (offset == SIOP_NSG)
    813       1.35    bouyer 		return;
    814       1.35    bouyer #ifdef DIAGNOSTIC
    815       1.35    bouyer 	if (offset > SIOP_NSG) {
    816       1.35    bouyer 		scsipi_printaddr(siop_cmd->xs->xs_periph);
    817       1.35    bouyer 		printf(": offset %d > %d\n", offset, SIOP_NSG);
    818       1.35    bouyer 		panic("siop_sdp: offset");
    819       1.35    bouyer 	}
    820        1.1    bouyer #endif
    821       1.35    bouyer 	/*
    822       1.35    bouyer 	 * Save data pointer. We do this by adjusting the tables to point
    823       1.37     perry 	 * at the begginning of the data not yet transfered.
    824       1.35    bouyer 	 * offset points to the first table with untransfered data.
    825       1.35    bouyer 	 */
    826       1.35    bouyer 
    827       1.35    bouyer 	/*
    828       1.35    bouyer 	 * before doing that we decrease resid from the ammount of data which
    829       1.35    bouyer 	 * has been transfered.
    830       1.35    bouyer 	 */
    831       1.35    bouyer 	siop_update_resid(siop_cmd, offset);
    832       1.35    bouyer 
    833       1.35    bouyer 	/*
    834       1.35    bouyer 	 * First let see if we have a resid from a phase mismatch. If so,
    835       1.35    bouyer 	 * we have to adjst the table at offset to remove transfered data.
    836       1.35    bouyer 	 */
    837       1.35    bouyer 	if (siop_cmd->flags & CMDFL_RESID) {
    838       1.35    bouyer 		siop_cmd->flags &= ~CMDFL_RESID;
    839       1.35    bouyer 		table = &siop_cmd->siop_tables->data[offset];
    840       1.35    bouyer 		/* "cut" already transfered data from this table */
    841       1.35    bouyer 		table->addr =
    842       1.44     skrll 		    siop_htoc32(sc, siop_ctoh32(sc, table->addr) +
    843       1.44     skrll 		    siop_ctoh32(sc, table->count) - siop_cmd->resid);
    844       1.44     skrll 		table->count = siop_htoc32(sc, siop_cmd->resid);
    845       1.35    bouyer 	}
    846       1.35    bouyer 
    847       1.35    bouyer 	/*
    848       1.35    bouyer 	 * now we can remove entries which have been transfered.
    849       1.35    bouyer 	 * We just move the entries with data left at the beggining of the
    850       1.35    bouyer 	 * tables
    851       1.35    bouyer 	 */
    852       1.35    bouyer 	memmove(&siop_cmd->siop_tables->data[0],
    853       1.35    bouyer 	    &siop_cmd->siop_tables->data[offset],
    854       1.35    bouyer 	    (SIOP_NSG - offset) * sizeof(scr_table_t));
    855       1.35    bouyer }
    856       1.35    bouyer 
    857       1.35    bouyer void
    858  1.46.10.1       jym siop_update_resid(struct siop_common_cmd *siop_cmd, int offset)
    859       1.35    bouyer {
    860       1.44     skrll 	struct siop_common_softc *sc = siop_cmd->siop_sc;
    861       1.35    bouyer 	scr_table_t *table;
    862       1.35    bouyer 	int i;
    863       1.35    bouyer 
    864       1.35    bouyer 	if ((siop_cmd->xs->xs_control & (XS_CTL_DATA_OUT | XS_CTL_DATA_IN))
    865       1.35    bouyer 	    == 0)
    866       1.35    bouyer 	    return; /* no data to transfer */
    867       1.35    bouyer 
    868       1.35    bouyer 	/*
    869       1.35    bouyer 	 * update resid. First account for the table entries which have
    870       1.35    bouyer 	 * been fully completed.
    871       1.35    bouyer 	 */
    872       1.35    bouyer 	for (i = 0; i < offset; i++)
    873       1.35    bouyer 		siop_cmd->xs->resid -=
    874       1.44     skrll 		    siop_ctoh32(sc, siop_cmd->siop_tables->data[i].count);
    875       1.35    bouyer 	/*
    876       1.35    bouyer 	 * if CMDFL_RESID is set, the last table (pointed by offset) is a
    877       1.35    bouyer 	 * partial transfers. If not, offset points to the entry folloing
    878       1.35    bouyer 	 * the last full transfer.
    879       1.35    bouyer 	 */
    880       1.35    bouyer 	if (siop_cmd->flags & CMDFL_RESID) {
    881       1.35    bouyer 		table = &siop_cmd->siop_tables->data[offset];
    882       1.44     skrll 		siop_cmd->xs->resid -=
    883       1.44     skrll 		    siop_ctoh32(sc, table->count) - siop_cmd->resid;
    884       1.35    bouyer 	}
    885        1.1    bouyer }
    886        1.1    bouyer 
    887       1.36    bouyer int
    888  1.46.10.1       jym siop_iwr(struct siop_common_cmd *siop_cmd)
    889       1.36    bouyer {
    890       1.36    bouyer 	int offset;
    891       1.36    bouyer 	scr_table_t *table; /* table with IWR */
    892       1.36    bouyer 	struct siop_common_softc *sc = siop_cmd->siop_sc;
    893  1.46.10.2       jym 
    894       1.36    bouyer 	/* handle ignore wide residue messages */
    895       1.36    bouyer 
    896       1.36    bouyer 	/* if target isn't wide, reject */
    897       1.36    bouyer 	if ((siop_cmd->siop_target->flags & TARF_ISWIDE) == 0) {
    898       1.44     skrll 		siop_cmd->siop_tables->t_msgout.count = siop_htoc32(sc, 1);
    899       1.36    bouyer 		siop_cmd->siop_tables->msg_out[0] = MSG_MESSAGE_REJECT;
    900       1.36    bouyer 		return SIOP_NEG_MSGOUT;
    901       1.36    bouyer 	}
    902       1.36    bouyer 	/* get index of current command in table */
    903       1.36    bouyer 	offset = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SCRATCHA + 1);
    904       1.36    bouyer 	/*
    905       1.36    bouyer 	 * if the current table did complete, we're now pointing at the
    906       1.36    bouyer 	 * next one. Go back one if we didn't see a phase mismatch.
    907       1.36    bouyer 	 */
    908       1.36    bouyer 	if ((siop_cmd->flags & CMDFL_RESID) == 0)
    909       1.36    bouyer 		offset--;
    910       1.36    bouyer 	table = &siop_cmd->siop_tables->data[offset];
    911       1.36    bouyer 
    912       1.36    bouyer 	if ((siop_cmd->flags & CMDFL_RESID) == 0) {
    913       1.44     skrll 		if (siop_ctoh32(sc, table->count) & 1) {
    914       1.36    bouyer 			/* we really got the number of bytes we expected */
    915       1.36    bouyer 			return SIOP_NEG_ACK;
    916       1.36    bouyer 		} else {
    917       1.36    bouyer 			/*
    918       1.36    bouyer 			 * now we really had a short xfer, by one byte.
    919       1.36    bouyer 			 * handle it just as if we had a phase mistmatch
    920       1.36    bouyer 			 * (there is a resid of one for this table).
    921       1.36    bouyer 			 * Update scratcha1 to reflect the fact that
    922       1.36    bouyer 			 * this xfer isn't complete.
    923       1.36    bouyer 			 */
    924       1.36    bouyer 			 siop_cmd->flags |= CMDFL_RESID;
    925       1.36    bouyer 			 siop_cmd->resid = 1;
    926       1.36    bouyer 			 bus_space_write_1(sc->sc_rt, sc->sc_rh,
    927       1.36    bouyer 			     SIOP_SCRATCHA + 1, offset);
    928       1.36    bouyer 			 return SIOP_NEG_ACK;
    929       1.36    bouyer 		}
    930       1.36    bouyer 	} else {
    931       1.36    bouyer 		/*
    932       1.36    bouyer 		 * we already have a short xfer for this table; it's
    933       1.36    bouyer 		 * just one byte less than we though it was
    934       1.36    bouyer 		 */
    935       1.36    bouyer 		siop_cmd->resid--;
    936       1.36    bouyer 		return SIOP_NEG_ACK;
    937       1.36    bouyer 	}
    938       1.36    bouyer }
    939       1.36    bouyer 
    940        1.1    bouyer void
    941  1.46.10.1       jym siop_clearfifo(struct siop_common_softc *sc)
    942        1.1    bouyer {
    943        1.1    bouyer 	int timeout = 0;
    944        1.1    bouyer 	int ctest3 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3);
    945        1.1    bouyer 
    946        1.1    bouyer #ifdef DEBUG_INTR
    947        1.1    bouyer 	printf("DMA fifo not empty !\n");
    948        1.1    bouyer #endif
    949        1.1    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3,
    950        1.1    bouyer 	    ctest3 | CTEST3_CLF);
    951        1.1    bouyer 	while ((bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3) &
    952        1.1    bouyer 	    CTEST3_CLF) != 0) {
    953        1.1    bouyer 		delay(1);
    954        1.1    bouyer 		if (++timeout > 1000) {
    955        1.1    bouyer 			printf("clear fifo failed\n");
    956        1.1    bouyer 			bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3,
    957        1.1    bouyer 			    bus_space_read_1(sc->sc_rt, sc->sc_rh,
    958        1.1    bouyer 			    SIOP_CTEST3) & ~CTEST3_CLF);
    959        1.1    bouyer 			return;
    960        1.1    bouyer 		}
    961        1.1    bouyer 	}
    962        1.3    bouyer }
    963        1.3    bouyer 
    964        1.3    bouyer int
    965  1.46.10.1       jym siop_modechange(struct siop_common_softc *sc)
    966        1.3    bouyer {
    967        1.3    bouyer 	int retry;
    968       1.27    bouyer 	int sist0, sist1, stest2;
    969  1.46.10.2       jym 
    970        1.3    bouyer 	for (retry = 0; retry < 5; retry++) {
    971        1.3    bouyer 		/*
    972        1.3    bouyer 		 * datasheet says to wait 100ms and re-read SIST1,
    973       1.14    bouyer 		 * to check that DIFFSENSE is stable.
    974        1.3    bouyer 		 * We may delay() 5 times for  100ms at interrupt time;
    975        1.3    bouyer 		 * hopefully this will not happen often.
    976        1.3    bouyer 		 */
    977        1.3    bouyer 		delay(100000);
    978        1.3    bouyer 		sist0 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SIST0);
    979        1.3    bouyer 		sist1 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SIST1);
    980        1.3    bouyer 		if (sist1 & SIEN1_SBMC)
    981        1.3    bouyer 			continue; /* we got an irq again */
    982       1.27    bouyer 		sc->mode = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_STEST4) &
    983        1.3    bouyer 		    STEST4_MODE_MASK;
    984        1.3    bouyer 		stest2 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2);
    985       1.27    bouyer 		switch(sc->mode) {
    986        1.3    bouyer 		case STEST4_MODE_DIF:
    987        1.3    bouyer 			printf("%s: switching to differential mode\n",
    988  1.46.10.2       jym 			    device_xname(sc->sc_dev));
    989        1.3    bouyer 			bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2,
    990        1.3    bouyer 			    stest2 | STEST2_DIF);
    991        1.3    bouyer 			break;
    992        1.3    bouyer 		case STEST4_MODE_SE:
    993        1.3    bouyer 			printf("%s: switching to single-ended mode\n",
    994  1.46.10.2       jym 			    device_xname(sc->sc_dev));
    995        1.3    bouyer 			bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2,
    996        1.3    bouyer 			    stest2 & ~STEST2_DIF);
    997        1.3    bouyer 			break;
    998        1.3    bouyer 		case STEST4_MODE_LVD:
    999        1.3    bouyer 			printf("%s: switching to LVD mode\n",
   1000  1.46.10.2       jym 			    device_xname(sc->sc_dev));
   1001        1.3    bouyer 			bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2,
   1002        1.3    bouyer 			    stest2 & ~STEST2_DIF);
   1003        1.3    bouyer 			break;
   1004        1.3    bouyer 		default:
   1005  1.46.10.2       jym 			aprint_error_dev(sc->sc_dev, "invalid SCSI mode 0x%x\n",
   1006       1.45    cegger 			    sc->mode);
   1007        1.3    bouyer 			return 0;
   1008        1.3    bouyer 		}
   1009        1.3    bouyer 		return 1;
   1010        1.3    bouyer 	}
   1011        1.3    bouyer 	printf("%s: timeout waiting for DIFFSENSE to stabilise\n",
   1012  1.46.10.2       jym 	    device_xname(sc->sc_dev));
   1013        1.3    bouyer 	return 0;
   1014        1.6    bouyer }
   1015        1.6    bouyer 
   1016        1.6    bouyer void
   1017  1.46.10.1       jym siop_resetbus(struct siop_common_softc *sc)
   1018        1.6    bouyer {
   1019        1.6    bouyer 	int scntl1;
   1020  1.46.10.2       jym 
   1021        1.6    bouyer 	scntl1 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1);
   1022        1.6    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1,
   1023        1.6    bouyer 	    scntl1 | SCNTL1_RST);
   1024        1.6    bouyer 	/* minimum 25 us, more time won't hurt */
   1025        1.6    bouyer 	delay(100);
   1026        1.6    bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1, scntl1);
   1027       1.17    bouyer }
   1028       1.17    bouyer 
   1029       1.17    bouyer void
   1030  1.46.10.1       jym siop_update_xfer_mode(struct siop_common_softc *sc, int target)
   1031       1.17    bouyer {
   1032       1.17    bouyer 	struct siop_common_target *siop_target = sc->targets[target];
   1033       1.17    bouyer 	struct scsipi_xfer_mode xm;
   1034       1.17    bouyer 
   1035       1.17    bouyer 	xm.xm_target = target;
   1036       1.17    bouyer 	xm.xm_mode = 0;
   1037       1.17    bouyer 	xm.xm_period = 0;
   1038       1.17    bouyer 	xm.xm_offset = 0;
   1039       1.26    bouyer 
   1040       1.17    bouyer 	if (siop_target->flags & TARF_ISWIDE)
   1041       1.17    bouyer 		xm.xm_mode |= PERIPH_CAP_WIDE16;
   1042       1.17    bouyer 	if (siop_target->period) {
   1043       1.17    bouyer 		xm.xm_period = siop_target->period;
   1044       1.17    bouyer 		xm.xm_offset = siop_target->offset;
   1045       1.17    bouyer 		xm.xm_mode |= PERIPH_CAP_SYNC;
   1046       1.17    bouyer 	}
   1047       1.28    bouyer 	if (siop_target->flags & TARF_TAG) {
   1048       1.28    bouyer 	/* 1010 workaround: can't do disconnect if not wide, so can't do tag */
   1049       1.28    bouyer 		if ((sc->features & SF_CHIP_GEBUG) == 0 ||
   1050       1.28    bouyer 		    (sc->targets[target]->flags & TARF_ISWIDE))
   1051       1.28    bouyer 			xm.xm_mode |= PERIPH_CAP_TQING;
   1052       1.28    bouyer 	}
   1053       1.28    bouyer 
   1054       1.17    bouyer 	scsipi_async_event(&sc->sc_chan, ASYNC_EVENT_XFER_MODE, &xm);
   1055        1.1    bouyer }
   1056