Home | History | Annotate | Line # | Download | only in ic
siop_common.c revision 1.12.2.2
      1  1.12.2.2  nathanw /*	$NetBSD: siop_common.c,v 1.12.2.2 2001/06/21 20:03:17 nathanw Exp $	*/
      2       1.1   bouyer 
      3       1.1   bouyer /*
      4       1.1   bouyer  * Copyright (c) 2000 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.1   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.1   bouyer  * 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.1   bouyer 
     35       1.1   bouyer #include <sys/param.h>
     36       1.1   bouyer #include <sys/systm.h>
     37       1.1   bouyer #include <sys/device.h>
     38       1.1   bouyer #include <sys/malloc.h>
     39       1.1   bouyer #include <sys/buf.h>
     40       1.1   bouyer #include <sys/kernel.h>
     41       1.1   bouyer #include <sys/scsiio.h>
     42       1.1   bouyer 
     43       1.1   bouyer #include <machine/endian.h>
     44       1.1   bouyer #include <machine/bus.h>
     45       1.1   bouyer 
     46       1.1   bouyer #include <dev/scsipi/scsi_all.h>
     47       1.1   bouyer #include <dev/scsipi/scsi_message.h>
     48       1.1   bouyer #include <dev/scsipi/scsipi_all.h>
     49       1.1   bouyer 
     50       1.1   bouyer #include <dev/scsipi/scsiconf.h>
     51       1.1   bouyer 
     52       1.1   bouyer #include <dev/ic/siopreg.h>
     53       1.1   bouyer #include <dev/ic/siopvar.h>
     54       1.1   bouyer #include <dev/ic/siopvar_common.h>
     55       1.1   bouyer 
     56       1.2   bouyer #undef DEBUG
     57       1.2   bouyer #undef DEBUG_DR
     58       1.1   bouyer 
     59       1.1   bouyer void
     60       1.1   bouyer siop_common_reset(sc)
     61       1.1   bouyer 	struct siop_softc *sc;
     62       1.1   bouyer {
     63       1.1   bouyer 	u_int32_t stest3;
     64       1.1   bouyer 
     65       1.1   bouyer 	/* reset the chip */
     66       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_ISTAT, ISTAT_SRST);
     67       1.1   bouyer 	delay(1000);
     68       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_ISTAT, 0);
     69       1.1   bouyer 
     70       1.1   bouyer 	/* init registers */
     71       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL0,
     72       1.1   bouyer 	    SCNTL0_ARB_MASK | SCNTL0_EPC | SCNTL0_AAP);
     73       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1, 0);
     74       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL3, sc->clock_div);
     75       1.7   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SXFER, 0);
     76       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_DIEN, 0xff);
     77       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SIEN0,
     78       1.1   bouyer 	    0xff & ~(SIEN0_CMP | SIEN0_SEL | SIEN0_RSL));
     79       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SIEN1,
     80       1.1   bouyer 	    0xff & ~(SIEN1_HTH | SIEN1_GEN));
     81       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2, 0);
     82       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST3, STEST3_TE);
     83       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STIME0,
     84       1.1   bouyer 	    (0xb << STIME0_SEL_SHIFT));
     85       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCID,
     86  1.12.2.2  nathanw 	    sc->sc_chan.chan_id | SCID_RRE);
     87       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_RESPID0,
     88  1.12.2.2  nathanw 	    1 << sc->sc_chan.chan_id);
     89       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_DCNTL,
     90       1.1   bouyer 	    (sc->features & SF_CHIP_PF) ? DCNTL_COM | DCNTL_PFEN : DCNTL_COM);
     91       1.1   bouyer 
     92       1.1   bouyer 	/* enable clock doubler or quadruler if appropriate */
     93       1.1   bouyer 	if (sc->features & (SF_CHIP_DBLR | SF_CHIP_QUAD)) {
     94       1.1   bouyer 		stest3 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_STEST3);
     95       1.1   bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST1,
     96       1.1   bouyer 		    STEST1_DBLEN);
     97       1.1   bouyer 		if (sc->features & SF_CHIP_QUAD) {
     98       1.1   bouyer 			/* wait for PPL to lock */
     99       1.1   bouyer 			while ((bus_space_read_1(sc->sc_rt, sc->sc_rh,
    100       1.1   bouyer 			    SIOP_STEST4) & STEST4_LOCK) == 0)
    101       1.1   bouyer 				delay(10);
    102       1.1   bouyer 		} else {
    103       1.1   bouyer 			/* data sheet says 20us - more won't hurt */
    104       1.1   bouyer 			delay(100);
    105       1.1   bouyer 		}
    106       1.1   bouyer 		/* halt scsi clock, select doubler/quad, restart clock */
    107       1.1   bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST3,
    108       1.1   bouyer 		    stest3 | STEST3_HSC);
    109       1.1   bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST1,
    110       1.1   bouyer 		    STEST1_DBLEN | STEST1_DBLSEL);
    111       1.1   bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST3, stest3);
    112       1.1   bouyer 	} else {
    113       1.1   bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST1, 0);
    114       1.1   bouyer 	}
    115       1.1   bouyer 	if (sc->features & SF_CHIP_FIFO)
    116       1.1   bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST5,
    117       1.1   bouyer 		    bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST5) |
    118       1.1   bouyer 		    CTEST5_DFS);
    119       1.1   bouyer 
    120       1.1   bouyer 	sc->sc_reset(sc);
    121       1.1   bouyer }
    122       1.1   bouyer 
    123      1.10   bouyer /* prepare tables before sending a cmd */
    124      1.10   bouyer void
    125      1.10   bouyer siop_setuptables(siop_cmd)
    126      1.10   bouyer 	struct siop_cmd *siop_cmd;
    127      1.10   bouyer {
    128      1.10   bouyer 	int i;
    129      1.10   bouyer 	struct siop_softc *sc = siop_cmd->siop_sc;
    130      1.10   bouyer 	struct scsipi_xfer *xs = siop_cmd->xs;
    131  1.12.2.2  nathanw 	int target = xs->xs_periph->periph_target;
    132  1.12.2.2  nathanw 	int lun = xs->xs_periph->periph_lun;
    133  1.12.2.2  nathanw 	int msgoffset = 1;
    134      1.10   bouyer 
    135      1.10   bouyer 	siop_cmd->siop_tables.id = htole32(sc->targets[target]->id);
    136      1.10   bouyer 	memset(siop_cmd->siop_tables.msg_out, 0, 8);
    137  1.12.2.2  nathanw 	/* request sense doesn't disconnect */
    138  1.12.2.2  nathanw 	if (xs->xs_control & XS_CTL_REQSENSE)
    139      1.12   bouyer 		siop_cmd->siop_tables.msg_out[0] = MSG_IDENTIFY(lun, 0);
    140  1.12.2.2  nathanw 	else
    141  1.12.2.2  nathanw 		siop_cmd->siop_tables.msg_out[0] = MSG_IDENTIFY(lun, 1);
    142      1.10   bouyer 	siop_cmd->siop_tables.t_msgout.count= htole32(1);
    143  1.12.2.2  nathanw 	if (xs->xs_tag_type != 0) {
    144  1.12.2.2  nathanw 		if ((sc->targets[target]->flags & TARF_TAG) == 0) {
    145  1.12.2.2  nathanw 			scsipi_printaddr(xs->xs_periph);
    146  1.12.2.2  nathanw 			printf(": tagged command type %d id %d\n",
    147  1.12.2.2  nathanw 			    siop_cmd->xs->xs_tag_type, siop_cmd->xs->xs_tag_id);
    148  1.12.2.2  nathanw 			panic("tagged command for non-tagging device\n");
    149  1.12.2.2  nathanw 		}
    150  1.12.2.2  nathanw 		siop_cmd->flags |= CMDFL_TAG;
    151  1.12.2.2  nathanw 		siop_cmd->siop_tables.msg_out[1] = siop_cmd->xs->xs_tag_type;
    152  1.12.2.2  nathanw 		siop_cmd->siop_tables.msg_out[2] = siop_cmd->xs->xs_tag_id + 1;
    153  1.12.2.2  nathanw 		siop_cmd->siop_tables.t_msgout.count = htole32(3);
    154  1.12.2.2  nathanw 		msgoffset = 3;
    155  1.12.2.2  nathanw 		siop_cmd->tag = siop_cmd->xs->xs_tag_id + 1;
    156  1.12.2.2  nathanw 	} else
    157  1.12.2.2  nathanw 		siop_cmd->tag = 0;
    158      1.10   bouyer 	if (sc->targets[target]->status == TARST_ASYNC) {
    159      1.10   bouyer 		if (sc->targets[target]->flags & TARF_WIDE) {
    160      1.10   bouyer 			sc->targets[target]->status = TARST_WIDE_NEG;
    161  1.12.2.2  nathanw 			siop_wdtr_msg(siop_cmd, msgoffset,
    162  1.12.2.2  nathanw 			    MSG_EXT_WDTR_BUS_16_BIT);
    163      1.10   bouyer 		} else if (sc->targets[target]->flags & TARF_SYNC) {
    164      1.10   bouyer 			sc->targets[target]->status = TARST_SYNC_NEG;
    165  1.12.2.2  nathanw 			siop_sdtr_msg(siop_cmd, msgoffset,
    166  1.12.2.2  nathanw 			    sc->minsync, sc->maxoff);
    167      1.10   bouyer 		} else {
    168      1.10   bouyer 			sc->targets[target]->status = TARST_OK;
    169  1.12.2.2  nathanw 			siop_update_xfer_mode(sc, target);
    170      1.10   bouyer 		}
    171      1.10   bouyer 	}
    172  1.12.2.2  nathanw 	if (xs->xs_tag_type != 0 && (siop_cmd->flags & CMDFL_TAG) == 0)
    173  1.12.2.2  nathanw 		printf("siop_setuptables: tagged CMD type 0x%x for target %d lun %d runs untagged, status 0x%x flags 0x%x\n", xs->xs_tag_type, target, lun, sc->targets[target]->status, sc->targets[target]->flags);
    174      1.11   bouyer 	siop_cmd->siop_tables.status =
    175      1.11   bouyer 	    htole32(SCSI_SIOP_NOSTATUS); /* set invalid status */
    176      1.10   bouyer 
    177      1.10   bouyer 	siop_cmd->siop_tables.cmd.count =
    178      1.10   bouyer 	    htole32(siop_cmd->dmamap_cmd->dm_segs[0].ds_len);
    179      1.10   bouyer 	siop_cmd->siop_tables.cmd.addr =
    180      1.10   bouyer 	    htole32(siop_cmd->dmamap_cmd->dm_segs[0].ds_addr);
    181  1.12.2.2  nathanw 	if (xs->xs_control & (XS_CTL_DATA_IN | XS_CTL_DATA_OUT)) {
    182      1.10   bouyer 		for (i = 0; i < siop_cmd->dmamap_data->dm_nsegs; i++) {
    183      1.10   bouyer 			siop_cmd->siop_tables.data[i].count =
    184      1.10   bouyer 			    htole32(siop_cmd->dmamap_data->dm_segs[i].ds_len);
    185      1.10   bouyer 			siop_cmd->siop_tables.data[i].addr =
    186      1.10   bouyer 			    htole32(siop_cmd->dmamap_data->dm_segs[i].ds_addr);
    187      1.10   bouyer 		}
    188      1.10   bouyer 	}
    189      1.10   bouyer 	siop_table_sync(siop_cmd, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
    190      1.10   bouyer }
    191      1.10   bouyer 
    192       1.1   bouyer int
    193       1.1   bouyer siop_wdtr_neg(siop_cmd)
    194       1.1   bouyer 	struct siop_cmd *siop_cmd;
    195       1.1   bouyer {
    196       1.9   bouyer 	struct siop_softc *sc = siop_cmd->siop_sc;
    197       1.1   bouyer 	struct siop_target *siop_target = siop_cmd->siop_target;
    198  1.12.2.2  nathanw 	int target = siop_cmd->xs->xs_periph->periph_target;
    199       1.9   bouyer 	struct siop_xfer_common *tables = &siop_cmd->siop_xfer->tables;
    200       1.1   bouyer 
    201       1.1   bouyer 	if (siop_target->status == TARST_WIDE_NEG) {
    202       1.1   bouyer 		/* we initiated wide negotiation */
    203       1.9   bouyer 		switch (tables->msg_in[3]) {
    204       1.1   bouyer 		case MSG_EXT_WDTR_BUS_8_BIT:
    205       1.9   bouyer 			siop_target->flags &= ~TARF_ISWIDE;
    206       1.1   bouyer 			sc->targets[target]->id &= ~(SCNTL3_EWS << 24);
    207       1.1   bouyer 			break;
    208       1.1   bouyer 		case MSG_EXT_WDTR_BUS_16_BIT:
    209       1.9   bouyer 			if (siop_target->flags & TARF_WIDE) {
    210       1.9   bouyer 				siop_target->flags |= TARF_ISWIDE;
    211       1.1   bouyer 				sc->targets[target]->id |= (SCNTL3_EWS << 24);
    212       1.1   bouyer 				break;
    213       1.1   bouyer 			}
    214       1.1   bouyer 		/* FALLTHROUH */
    215       1.1   bouyer 		default:
    216       1.1   bouyer 			/*
    217       1.1   bouyer  			 * hum, we got more than what we can handle, shoudn't
    218       1.1   bouyer 			 * happen. Reject, and stay async
    219       1.1   bouyer 			 */
    220       1.9   bouyer 			siop_target->flags &= ~TARF_ISWIDE;
    221       1.1   bouyer 			siop_target->status = TARST_OK;
    222  1.12.2.2  nathanw 			siop_target->offset = siop_target->period = 0;
    223  1.12.2.2  nathanw 			siop_update_xfer_mode(sc, target);
    224       1.1   bouyer 			printf("%s: rejecting invalid wide negotiation from "
    225       1.1   bouyer 			    "target %d (%d)\n", sc->sc_dev.dv_xname, target,
    226       1.9   bouyer 			    tables->msg_in[3]);
    227       1.9   bouyer 			tables->t_msgout.count= htole32(1);
    228       1.9   bouyer 			tables->msg_out[0] = MSG_MESSAGE_REJECT;
    229       1.1   bouyer 			return SIOP_NEG_MSGOUT;
    230       1.1   bouyer 		}
    231       1.9   bouyer 		tables->id = htole32(sc->targets[target]->id);
    232       1.1   bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh,
    233       1.1   bouyer 		    SIOP_SCNTL3,
    234       1.1   bouyer 		    (sc->targets[target]->id >> 24) & 0xff);
    235       1.1   bouyer 		/* we now need to do sync */
    236       1.9   bouyer 		if (siop_target->flags & TARF_SYNC) {
    237       1.6   bouyer 			siop_target->status = TARST_SYNC_NEG;
    238      1.10   bouyer 			siop_sdtr_msg(siop_cmd, 0, sc->minsync, sc->maxoff);
    239       1.6   bouyer 			return SIOP_NEG_MSGOUT;
    240       1.6   bouyer 		} else {
    241       1.6   bouyer 			siop_target->status = TARST_OK;
    242  1.12.2.2  nathanw 			siop_update_xfer_mode(sc, target);
    243       1.6   bouyer 			return SIOP_NEG_ACK;
    244       1.6   bouyer 		}
    245       1.1   bouyer 	} else {
    246       1.1   bouyer 		/* target initiated wide negotiation */
    247       1.9   bouyer 		if (tables->msg_in[3] >= MSG_EXT_WDTR_BUS_16_BIT
    248       1.9   bouyer 		    && (siop_target->flags & TARF_WIDE)) {
    249       1.9   bouyer 			siop_target->flags |= TARF_ISWIDE;
    250       1.1   bouyer 			sc->targets[target]->id |= SCNTL3_EWS << 24;
    251       1.1   bouyer 		} else {
    252       1.9   bouyer 			siop_target->flags &= ~TARF_ISWIDE;
    253       1.1   bouyer 			sc->targets[target]->id &= ~(SCNTL3_EWS << 24);
    254       1.1   bouyer 		}
    255       1.9   bouyer 		tables->id = htole32(sc->targets[target]->id);
    256       1.1   bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL3,
    257       1.1   bouyer 		    (sc->targets[target]->id >> 24) & 0xff);
    258       1.1   bouyer 		/*
    259       1.1   bouyer 		 * we did reset wide parameters, so fall back to async,
    260       1.8   bouyer 		 * but don't schedule a sync neg, target should initiate it
    261       1.1   bouyer 		 */
    262       1.1   bouyer 		siop_target->status = TARST_OK;
    263  1.12.2.2  nathanw 		siop_target->offset = siop_target->period = 0;
    264  1.12.2.2  nathanw 		siop_update_xfer_mode(sc, target);
    265      1.10   bouyer 		siop_wdtr_msg(siop_cmd, 0, (siop_target->flags & TARF_ISWIDE) ?
    266      1.10   bouyer 		    MSG_EXT_WDTR_BUS_16_BIT : MSG_EXT_WDTR_BUS_8_BIT);
    267       1.1   bouyer 		return SIOP_NEG_MSGOUT;
    268       1.1   bouyer 	}
    269       1.1   bouyer }
    270       1.1   bouyer 
    271       1.1   bouyer int
    272       1.1   bouyer siop_sdtr_neg(siop_cmd)
    273       1.1   bouyer 	struct siop_cmd *siop_cmd;
    274       1.1   bouyer {
    275       1.9   bouyer 	struct siop_softc *sc = siop_cmd->siop_sc;
    276       1.1   bouyer 	struct siop_target *siop_target = siop_cmd->siop_target;
    277  1.12.2.2  nathanw 	int target = siop_cmd->xs->xs_periph->periph_target;
    278       1.1   bouyer 	int sync, offset, i;
    279       1.1   bouyer 	int send_msgout = 0;
    280       1.9   bouyer 	struct siop_xfer_common *tables = &siop_cmd->siop_xfer->tables;
    281       1.1   bouyer 
    282       1.9   bouyer 	sync = tables->msg_in[3];
    283       1.9   bouyer 	offset = tables->msg_in[4];
    284       1.1   bouyer 
    285       1.1   bouyer 	if (siop_target->status == TARST_SYNC_NEG) {
    286       1.1   bouyer 		/* we initiated sync negotiation */
    287       1.1   bouyer 		siop_target->status = TARST_OK;
    288       1.1   bouyer #ifdef DEBUG
    289       1.1   bouyer 		printf("sdtr: sync %d offset %d\n", sync, offset);
    290       1.1   bouyer #endif
    291       1.1   bouyer 		if (offset > sc->maxoff || sync < sc->minsync ||
    292       1.1   bouyer 			sync > sc->maxsync)
    293       1.1   bouyer 			goto reject;
    294       1.1   bouyer 		for (i = 0; i < sizeof(scf_period) / sizeof(scf_period[0]);
    295       1.1   bouyer 		    i++) {
    296       1.1   bouyer 			if (sc->clock_period != scf_period[i].clock)
    297       1.1   bouyer 				continue;
    298       1.1   bouyer 			if (scf_period[i].period == sync) {
    299       1.1   bouyer 				/* ok, found it. we now are sync. */
    300  1.12.2.2  nathanw 				siop_target->offset = offset;
    301  1.12.2.2  nathanw 				siop_target->period = sync;
    302       1.1   bouyer 				sc->targets[target]->id &=
    303       1.1   bouyer 				    ~(SCNTL3_SCF_MASK << 24);
    304       1.1   bouyer 				sc->targets[target]->id |= scf_period[i].scf
    305       1.1   bouyer 				    << (24 + SCNTL3_SCF_SHIFT);
    306       1.1   bouyer 				if (sync < 25) /* Ultra */
    307       1.1   bouyer 					sc->targets[target]->id |=
    308       1.1   bouyer 					    SCNTL3_ULTRA << 24;
    309       1.1   bouyer 				else
    310       1.1   bouyer 					sc->targets[target]->id &=
    311       1.1   bouyer 					    ~(SCNTL3_ULTRA << 24);
    312       1.1   bouyer 				sc->targets[target]->id &=
    313       1.7   bouyer 				    ~(SXFER_MO_MASK << 8);
    314       1.1   bouyer 				sc->targets[target]->id |=
    315       1.7   bouyer 				    (offset & SXFER_MO_MASK) << 8;
    316       1.1   bouyer 				goto end;
    317       1.1   bouyer 			}
    318       1.1   bouyer 		}
    319       1.1   bouyer 		/*
    320       1.1   bouyer 		 * we didn't find it in our table, do async and send reject
    321       1.1   bouyer 		 * msg
    322       1.1   bouyer 		 */
    323       1.1   bouyer reject:
    324       1.1   bouyer 		send_msgout = 1;
    325       1.9   bouyer 		tables->t_msgout.count= htole32(1);
    326       1.9   bouyer 		tables->msg_out[0] = MSG_MESSAGE_REJECT;
    327       1.1   bouyer 		sc->targets[target]->id &= ~(SCNTL3_SCF_MASK << 24);
    328       1.1   bouyer 		sc->targets[target]->id &= ~(SCNTL3_ULTRA << 24);
    329       1.7   bouyer 		sc->targets[target]->id &= ~(SXFER_MO_MASK << 8);
    330  1.12.2.2  nathanw 		siop_target->offset = siop_target->period = 0;
    331       1.1   bouyer 	} else { /* target initiated sync neg */
    332       1.1   bouyer #ifdef DEBUG
    333       1.1   bouyer 		printf("sdtr (target): sync %d offset %d\n", sync, offset);
    334       1.1   bouyer #endif
    335       1.1   bouyer 		if (offset == 0 || sync > sc->maxsync) { /* async */
    336       1.1   bouyer 			goto async;
    337       1.1   bouyer 		}
    338       1.1   bouyer 		if (offset > sc->maxoff)
    339       1.1   bouyer 			offset = sc->maxoff;
    340       1.1   bouyer 		if (sync < sc->minsync)
    341       1.1   bouyer 			sync = sc->minsync;
    342       1.1   bouyer 		/* look for sync period */
    343       1.1   bouyer 		for (i = 0; i < sizeof(scf_period) / sizeof(scf_period[0]);
    344       1.1   bouyer 		    i++) {
    345       1.1   bouyer 			if (sc->clock_period != scf_period[i].clock)
    346       1.1   bouyer 				continue;
    347       1.1   bouyer 			if (scf_period[i].period == sync) {
    348       1.1   bouyer 				/* ok, found it. we now are sync. */
    349  1.12.2.2  nathanw 				siop_target->offset = offset;
    350  1.12.2.2  nathanw 				siop_target->period = sync;
    351       1.1   bouyer 				sc->targets[target]->id &=
    352       1.1   bouyer 				    ~(SCNTL3_SCF_MASK << 24);
    353       1.1   bouyer 				sc->targets[target]->id |= scf_period[i].scf
    354       1.1   bouyer 				    << (24 + SCNTL3_SCF_SHIFT);
    355       1.1   bouyer 				if (sync < 25) /* Ultra */
    356       1.1   bouyer 					sc->targets[target]->id |=
    357       1.1   bouyer 					    SCNTL3_ULTRA << 24;
    358       1.1   bouyer 				else
    359       1.1   bouyer 					sc->targets[target]->id &=
    360       1.1   bouyer 					    ~(SCNTL3_ULTRA << 24);
    361       1.1   bouyer 				sc->targets[target]->id &=
    362       1.7   bouyer 				    ~(SXFER_MO_MASK << 8);
    363       1.1   bouyer 				sc->targets[target]->id |=
    364       1.7   bouyer 				    (offset & SXFER_MO_MASK) << 8;
    365      1.10   bouyer 				siop_sdtr_msg(siop_cmd, 0, sync, offset);
    366       1.1   bouyer 				send_msgout = 1;
    367       1.1   bouyer 				goto end;
    368       1.1   bouyer 			}
    369       1.1   bouyer 		}
    370       1.1   bouyer async:
    371  1.12.2.2  nathanw 		siop_target->offset = siop_target->period = 0;
    372       1.1   bouyer 		sc->targets[target]->id &= ~(SCNTL3_SCF_MASK << 24);
    373       1.1   bouyer 		sc->targets[target]->id &= ~(SCNTL3_ULTRA << 24);
    374       1.7   bouyer 		sc->targets[target]->id &= ~(SXFER_MO_MASK << 8);
    375      1.10   bouyer 		siop_sdtr_msg(siop_cmd, 0, 0, 0);
    376       1.1   bouyer 		send_msgout = 1;
    377       1.1   bouyer 	}
    378       1.1   bouyer end:
    379  1.12.2.2  nathanw 	if (siop_target->status == TARST_OK)
    380  1.12.2.2  nathanw 		siop_update_xfer_mode(sc, target);
    381       1.1   bouyer #ifdef DEBUG
    382       1.1   bouyer 	printf("id now 0x%x\n", sc->targets[target]->id);
    383       1.1   bouyer #endif
    384       1.9   bouyer 	tables->id = htole32(sc->targets[target]->id);
    385       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL3,
    386       1.1   bouyer 	    (sc->targets[target]->id >> 24) & 0xff);
    387       1.7   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SXFER,
    388       1.1   bouyer 	    (sc->targets[target]->id >> 8) & 0xff);
    389       1.1   bouyer 	if (send_msgout) {
    390       1.1   bouyer 		return SIOP_NEG_MSGOUT;
    391       1.1   bouyer 	} else {
    392       1.1   bouyer 		return SIOP_NEG_ACK;
    393       1.1   bouyer 	}
    394       1.1   bouyer }
    395       1.1   bouyer 
    396       1.1   bouyer void
    397      1.10   bouyer siop_sdtr_msg(siop_cmd, offset, ssync, soff)
    398      1.10   bouyer 	struct siop_cmd *siop_cmd;
    399      1.10   bouyer 	int offset;
    400      1.10   bouyer 	int ssync, soff;
    401      1.10   bouyer {
    402      1.10   bouyer 	siop_cmd->siop_tables.msg_out[offset + 0] = MSG_EXTENDED;
    403      1.10   bouyer 	siop_cmd->siop_tables.msg_out[offset + 1] = MSG_EXT_SDTR_LEN;
    404      1.10   bouyer 	siop_cmd->siop_tables.msg_out[offset + 2] = MSG_EXT_SDTR;
    405      1.10   bouyer 	siop_cmd->siop_tables.msg_out[offset + 3] = ssync;
    406      1.10   bouyer 	siop_cmd->siop_tables.msg_out[offset + 4] = soff;
    407      1.10   bouyer 	siop_cmd->siop_tables.t_msgout.count =
    408      1.10   bouyer 	    htole32(offset + MSG_EXT_SDTR_LEN + 2);
    409      1.10   bouyer }
    410      1.10   bouyer 
    411      1.10   bouyer void
    412      1.10   bouyer siop_wdtr_msg(siop_cmd, offset, wide)
    413      1.10   bouyer 	struct siop_cmd *siop_cmd;
    414      1.10   bouyer 	int offset;
    415      1.10   bouyer {
    416      1.10   bouyer 	siop_cmd->siop_tables.msg_out[offset + 0] = MSG_EXTENDED;
    417      1.10   bouyer 	siop_cmd->siop_tables.msg_out[offset + 1] = MSG_EXT_WDTR_LEN;
    418      1.10   bouyer 	siop_cmd->siop_tables.msg_out[offset + 2] = MSG_EXT_WDTR;
    419      1.10   bouyer 	siop_cmd->siop_tables.msg_out[offset + 3] = wide;
    420      1.10   bouyer 	siop_cmd->siop_tables.t_msgout.count =
    421      1.10   bouyer 	    htole32(offset + MSG_EXT_WDTR_LEN + 2);
    422      1.10   bouyer }
    423      1.10   bouyer 
    424      1.10   bouyer void
    425       1.1   bouyer siop_minphys(bp)
    426       1.1   bouyer 	struct buf *bp;
    427       1.1   bouyer {
    428       1.1   bouyer 	minphys(bp);
    429       1.1   bouyer }
    430       1.1   bouyer 
    431       1.1   bouyer int
    432  1.12.2.2  nathanw siop_ioctl(chan, cmd, arg, flag, p)
    433  1.12.2.2  nathanw 	struct scsipi_channel *chan;
    434       1.1   bouyer 	u_long cmd;
    435       1.1   bouyer 	caddr_t arg;
    436       1.1   bouyer 	int flag;
    437       1.1   bouyer 	struct proc *p;
    438       1.1   bouyer {
    439  1.12.2.2  nathanw 	struct siop_softc *sc = (void *)chan->chan_adapter->adapt_dev;
    440       1.1   bouyer 	u_int8_t scntl1;
    441       1.1   bouyer 	int s;
    442       1.1   bouyer 
    443       1.1   bouyer 	switch (cmd) {
    444       1.1   bouyer 	case SCBUSIORESET:
    445       1.1   bouyer 		s = splbio();
    446       1.1   bouyer 		scntl1 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1);
    447       1.1   bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1,
    448       1.1   bouyer 		    scntl1 | SCNTL1_RST);
    449       1.1   bouyer 		/* minimum 25 us, more time won't hurt */
    450       1.1   bouyer 		delay(100);
    451       1.1   bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1, scntl1);
    452       1.1   bouyer 		splx(s);
    453       1.1   bouyer 		return (0);
    454       1.1   bouyer 	default:
    455       1.1   bouyer 		return (ENOTTY);
    456       1.1   bouyer 	}
    457       1.1   bouyer }
    458       1.1   bouyer 
    459       1.1   bouyer void
    460       1.1   bouyer siop_sdp(siop_cmd)
    461       1.1   bouyer 	struct siop_cmd *siop_cmd;
    462       1.1   bouyer {
    463       1.1   bouyer 	/* save data pointer. Handle async only for now */
    464       1.1   bouyer 	int offset, dbc, sstat;
    465       1.9   bouyer 	struct siop_softc *sc = siop_cmd->siop_sc;
    466       1.1   bouyer 	scr_table_t *table; /* table to patch */
    467       1.1   bouyer 
    468       1.1   bouyer 	if ((siop_cmd->xs->xs_control & (XS_CTL_DATA_OUT | XS_CTL_DATA_IN))
    469       1.1   bouyer 	    == 0)
    470       1.1   bouyer 	    return; /* no data pointers to save */
    471       1.1   bouyer 	offset = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SCRATCHA + 1);
    472       1.1   bouyer 	if (offset >= SIOP_NSG) {
    473       1.1   bouyer 		printf("%s: bad offset in siop_sdp (%d)\n",
    474       1.1   bouyer 		    sc->sc_dev.dv_xname, offset);
    475       1.1   bouyer 		return;
    476       1.1   bouyer 	}
    477       1.9   bouyer 	table = &siop_cmd->siop_xfer->tables.data[offset];
    478       1.1   bouyer #ifdef DEBUG_DR
    479       1.1   bouyer 	printf("sdp: offset %d count=%d addr=0x%x ", offset,
    480       1.1   bouyer 	    table->count, table->addr);
    481       1.1   bouyer #endif
    482       1.1   bouyer 	dbc = bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_DBC) & 0x00ffffff;
    483       1.1   bouyer 	if (siop_cmd->xs->xs_control & XS_CTL_DATA_OUT) {
    484  1.12.2.1  nathanw 		if (sc->features & SF_CHIP_DFBC) {
    485  1.12.2.1  nathanw 			dbc +=
    486  1.12.2.1  nathanw 			    bus_space_read_2(sc->sc_rt, sc->sc_rh, SIOP_DFBC);
    487       1.1   bouyer 		} else {
    488  1.12.2.1  nathanw 			/* need to account stale data in FIFO */
    489  1.12.2.1  nathanw 			int dfifo =
    490  1.12.2.1  nathanw 			    bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_DFIFO);
    491  1.12.2.1  nathanw 			if (sc->features & SF_CHIP_FIFO) {
    492  1.12.2.1  nathanw 				dfifo |= (bus_space_read_1(sc->sc_rt, sc->sc_rh,
    493  1.12.2.1  nathanw 				    SIOP_CTEST5) & CTEST5_BOMASK) << 8;
    494  1.12.2.1  nathanw 				dbc += (dfifo - (dbc & 0x3ff)) & 0x3ff;
    495  1.12.2.1  nathanw 			} else {
    496  1.12.2.1  nathanw 				dbc += (dfifo - (dbc & 0x7f)) & 0x7f;
    497  1.12.2.1  nathanw 			}
    498       1.1   bouyer 		}
    499       1.1   bouyer 		sstat = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SSTAT0);
    500       1.1   bouyer 		if (sstat & SSTAT0_OLF)
    501       1.1   bouyer 			dbc++;
    502  1.12.2.1  nathanw 		if ((sstat & SSTAT0_ORF) && (sc->features & SF_CHIP_DFBC) == 0)
    503       1.1   bouyer 			dbc++;
    504       1.9   bouyer 		if (siop_cmd->siop_target->flags & TARF_ISWIDE) {
    505       1.1   bouyer 			sstat = bus_space_read_1(sc->sc_rt, sc->sc_rh,
    506       1.1   bouyer 			    SIOP_SSTAT2);
    507       1.1   bouyer 			if (sstat & SSTAT2_OLF1)
    508       1.1   bouyer 				dbc++;
    509  1.12.2.1  nathanw 			if ((sstat & SSTAT2_ORF1) &&
    510  1.12.2.1  nathanw 			    (sc->features & SF_CHIP_DFBC) == 0)
    511       1.1   bouyer 				dbc++;
    512       1.1   bouyer 		}
    513       1.1   bouyer 		/* clear the FIFO */
    514       1.1   bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3,
    515       1.1   bouyer 		    bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3) |
    516       1.1   bouyer 		    CTEST3_CLF);
    517       1.1   bouyer 	}
    518       1.1   bouyer 	table->addr =
    519       1.1   bouyer 	    htole32(le32toh(table->addr) + le32toh(table->count) - dbc);
    520       1.1   bouyer 	table->count = htole32(dbc);
    521       1.1   bouyer #ifdef DEBUG_DR
    522       1.1   bouyer 	printf("now count=%d addr=0x%x\n", table->count, table->addr);
    523       1.1   bouyer #endif
    524       1.1   bouyer }
    525       1.1   bouyer 
    526       1.1   bouyer void
    527       1.1   bouyer siop_clearfifo(sc)
    528       1.1   bouyer 	struct siop_softc *sc;
    529       1.1   bouyer {
    530       1.1   bouyer 	int timeout = 0;
    531       1.1   bouyer 	int ctest3 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3);
    532       1.1   bouyer 
    533       1.1   bouyer #ifdef DEBUG_INTR
    534       1.1   bouyer 	printf("DMA fifo not empty !\n");
    535       1.1   bouyer #endif
    536       1.1   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3,
    537       1.1   bouyer 	    ctest3 | CTEST3_CLF);
    538       1.1   bouyer 	while ((bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3) &
    539       1.1   bouyer 	    CTEST3_CLF) != 0) {
    540       1.1   bouyer 		delay(1);
    541       1.1   bouyer 		if (++timeout > 1000) {
    542       1.1   bouyer 			printf("clear fifo failed\n");
    543       1.1   bouyer 			bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3,
    544       1.1   bouyer 			    bus_space_read_1(sc->sc_rt, sc->sc_rh,
    545       1.1   bouyer 			    SIOP_CTEST3) & ~CTEST3_CLF);
    546       1.1   bouyer 			return;
    547       1.1   bouyer 		}
    548       1.1   bouyer 	}
    549       1.3   bouyer }
    550       1.3   bouyer 
    551       1.3   bouyer int
    552       1.3   bouyer siop_modechange(sc)
    553       1.3   bouyer 	struct siop_softc *sc;
    554       1.3   bouyer {
    555       1.3   bouyer 	int retry;
    556       1.3   bouyer 	int sist0, sist1, stest2, stest4;
    557       1.3   bouyer 	for (retry = 0; retry < 5; retry++) {
    558       1.3   bouyer 		/*
    559       1.3   bouyer 		 * datasheet says to wait 100ms and re-read SIST1,
    560  1.12.2.2  nathanw 		 * to check that DIFFSENSE is stable.
    561       1.3   bouyer 		 * We may delay() 5 times for  100ms at interrupt time;
    562       1.3   bouyer 		 * hopefully this will not happen often.
    563       1.3   bouyer 		 */
    564       1.3   bouyer 		delay(100000);
    565       1.3   bouyer 		sist0 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SIST0);
    566       1.3   bouyer 		sist1 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SIST1);
    567       1.3   bouyer 		if (sist1 & SIEN1_SBMC)
    568       1.3   bouyer 			continue; /* we got an irq again */
    569       1.3   bouyer 		stest4 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_STEST4) &
    570       1.3   bouyer 		    STEST4_MODE_MASK;
    571       1.3   bouyer 		stest2 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2);
    572       1.3   bouyer 		switch(stest4) {
    573       1.3   bouyer 		case STEST4_MODE_DIF:
    574       1.3   bouyer 			printf("%s: switching to differential mode\n",
    575       1.3   bouyer 			    sc->sc_dev.dv_xname);
    576       1.3   bouyer 			bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2,
    577       1.3   bouyer 			    stest2 | STEST2_DIF);
    578       1.3   bouyer 			break;
    579       1.3   bouyer 		case STEST4_MODE_SE:
    580       1.3   bouyer 			printf("%s: switching to single-ended mode\n",
    581       1.3   bouyer 			    sc->sc_dev.dv_xname);
    582       1.3   bouyer 			bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2,
    583       1.3   bouyer 			    stest2 & ~STEST2_DIF);
    584       1.3   bouyer 			break;
    585       1.3   bouyer 		case STEST4_MODE_LVD:
    586       1.3   bouyer 			printf("%s: switching to LVD mode\n",
    587       1.3   bouyer 			    sc->sc_dev.dv_xname);
    588       1.3   bouyer 			bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2,
    589       1.3   bouyer 			    stest2 & ~STEST2_DIF);
    590       1.3   bouyer 			break;
    591       1.3   bouyer 		default:
    592       1.3   bouyer 			printf("%s: invalid SCSI mode 0x%x\n",
    593       1.3   bouyer 			    sc->sc_dev.dv_xname, stest4);
    594       1.3   bouyer 			return 0;
    595       1.3   bouyer 		}
    596       1.3   bouyer 		bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST0,
    597       1.3   bouyer 		    stest4 >> 2);
    598       1.3   bouyer 		return 1;
    599       1.3   bouyer 	}
    600       1.3   bouyer 	printf("%s: timeout waiting for DIFFSENSE to stabilise\n",
    601       1.3   bouyer 	    sc->sc_dev.dv_xname);
    602       1.3   bouyer 	return 0;
    603       1.6   bouyer }
    604       1.6   bouyer 
    605       1.6   bouyer void
    606       1.6   bouyer siop_resetbus(sc)
    607       1.6   bouyer 	struct siop_softc *sc;
    608       1.6   bouyer {
    609       1.6   bouyer 	int scntl1;
    610       1.6   bouyer 	scntl1 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1);
    611       1.6   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1,
    612       1.6   bouyer 	    scntl1 | SCNTL1_RST);
    613       1.6   bouyer 	/* minimum 25 us, more time won't hurt */
    614       1.6   bouyer 	delay(100);
    615       1.6   bouyer 	bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1, scntl1);
    616       1.1   bouyer }
    617