File:  [DragonFly] / src / sys / dev / disk / stg / tmc18c30.c
Revision 1.7: download - view: text, annotated - select for diffs
Thu Feb 12 00:00:18 2004 UTC (10 years, 9 months ago) by dillon
Branches: MAIN
CVS tags: HEAD, DragonFly_Stable, DragonFly_Snap29Sep2004, DragonFly_Snap13Sep2004, DragonFly_RELEASE_1_2_Slip, DragonFly_RELEASE_1_2, DragonFly_1_0_REL, DragonFly_1_0_RC1, DragonFly_1_0A_REL
sys/dev __FreeBSD__ -> __DragonFly__ cleanups.

Submitted-by: Aaron Malone <aaron@munge.net>

    1: /*	$FreeBSD: src/sys/dev/stg/tmc18c30.c,v 1.1.2.5 2001/12/17 13:30:19 non Exp $	*/
    2: /*	$DragonFly: src/sys/dev/disk/stg/tmc18c30.c,v 1.7 2004/02/12 00:00:18 dillon Exp $	*/
    3: /*	$NecBSD: tmc18c30.c,v 1.28.12.3 2001/06/19 04:35:48 honda Exp $	*/
    4: /*	$NetBSD$	*/
    5: 
    6: #define	STG_DEBUG
    7: #define	STG_STATICS
    8: #define	STG_IO_CONTROL_FLAGS	(STG_FIFO_INTERRUPTS | STG_WAIT_FOR_SELECT)
    9: 
   10: /*
   11:  * [NetBSD for NEC PC-98 series]
   12:  *  Copyright (c) 1996, 1997, 1998, 1999, 2000, 2001
   13:  *	NetBSD/pc98 porting staff. All rights reserved.
   14:  *  Copyright (c) 1996, 1997, 1998, 1999, 2000, 2001
   15:  *	Naofumi HONDA. All rights reserved.
   16:  *  Copyright (c) 1996, 1997, 1998, 1999
   17:  *	Kouichi Matsuda. All rights reserved.
   18:  * 
   19:  *  Redistribution and use in source and binary forms, with or without
   20:  *  modification, are permitted provided that the following conditions
   21:  *  are met:
   22:  *  1. Redistributions of source code must retain the above copyright
   23:  *     notice, this list of conditions and the following disclaimer.
   24:  *  2. Redistributions in binary form must reproduce the above copyright
   25:  *     notice, this list of conditions and the following disclaimer in the
   26:  *     documentation and/or other materials provided with the distribution.
   27:  *  3. The name of the author may not be used to endorse or promote products
   28:  *     derived from this software without specific prior written permission.
   29:  * 
   30:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   31:  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   32:  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   33:  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
   34:  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   35:  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   36:  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   37:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   38:  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   39:  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   40:  * POSSIBILITY OF SUCH DAMAGE.
   41:  */
   42: #include "opt_ddb.h"
   43: 
   44: #include <sys/param.h>
   45: #include <sys/systm.h>
   46: #include <sys/kernel.h>
   47: #include <sys/buf.h>
   48: #include <sys/queue.h>
   49: #include <sys/malloc.h>
   50: #include <sys/errno.h>
   51: 
   52: #ifdef __NetBSD__
   53: #include <sys/device.h>
   54: #include <machine/bus.h>
   55: #include <machine/intr.h>
   56: 
   57: #include <dev/scsipi/scsi_all.h>
   58: #include <dev/scsipi/scsipi_all.h>
   59: #include <dev/scsipi/scsiconf.h>
   60: #include <dev/scsipi/scsi_disk.h>
   61: 
   62: #include <machine/dvcfg.h>
   63: #include <machine/physio_proc.h>
   64: 
   65: #include <i386/Cbus/dev/scsi_low.h>
   66: #include <i386/Cbus/dev/tmc18c30reg.h>
   67: #include <i386/Cbus/dev/tmc18c30var.h>
   68: #endif /* __NetBSD__ */
   69: 
   70: #ifdef __DragonFly__
   71: #include <machine/clock.h>
   72: #include <machine/cpu.h>
   73: #include <machine/bus_pio.h>
   74: #include <machine/bus.h>
   75: 
   76: #include <machine/dvcfg.h>
   77: #include <machine/physio_proc.h>
   78: 
   79: #include <bus/cam/scsi/scsi_low.h>
   80: #include "tmc18c30reg.h"
   81: #include "tmc18c30var.h"
   82: #endif /* __DragonFly__ */
   83: 
   84: /***************************************************
   85:  * USER SETTINGS
   86:  ***************************************************/
   87: /* DEVICE CONFIGURATION FLAGS (MINOR)
   88:  *
   89:  * 0x01   DISCONECT OFF
   90:  * 0x02   PARITY LINE OFF
   91:  * 0x04   IDENTIFY MSG OFF ( = single lun)
   92:  * 0x08   SYNC TRANSFER OFF
   93:  */
   94: /* #define	STG_SYNC_SUPPORT */	/* NOT YET but easy */
   95: 
   96: /* For the 512 fifo type: change below */
   97: #define	TMC18C30_FIFOSZ	0x800
   98: #define	TMC18C30_FCBSZ	0x200
   99: #define	TMC18C50_FIFOSZ	0x2000
  100: #define	TMC18C50_FCBSZ	0x400
  101: 
  102: #define	STG_MAX_DATA_SIZE	(64 * 1024)
  103: #define	STG_DELAY_MAX			(2 * 1000 * 1000)
  104: #define	STG_DELAY_INTERVAL		(1)
  105: #define	STG_DELAY_SELECT_POLLING_MAX	(5 * 1000 * 1000)
  106: 
  107: /***************************************************
  108:  * PARAMS
  109:  ***************************************************/
  110: #define	STG_NTARGETS	8
  111: #define	STG_NLUNS	8
  112: 
  113: /***************************************************
  114:  * DEBUG
  115:  ***************************************************/
  116: #ifdef	STG_DEBUG
  117: int stg_debug;
  118: #endif	/* STG_DEBUG */
  119: 
  120: #ifdef	STG_STATICS
  121: struct stg_statics {
  122: 	int arbit_fail_0;
  123: 	int arbit_fail_1;
  124: 	int disconnect;
  125: 	int reselect;
  126: } stg_statics;
  127: #endif	/* STG_STATICS */
  128: 
  129: /***************************************************
  130:  * IO control flags
  131:  ***************************************************/
  132: #define	STG_FIFO_INTERRUPTS	0x0001
  133: #define	STG_WAIT_FOR_SELECT	0x0100
  134: 
  135: int stg_io_control = STG_IO_CONTROL_FLAGS;
  136: 
  137: /***************************************************
  138:  * DEVICE STRUCTURE
  139:  ***************************************************/
  140: extern struct cfdriver stg_cd;
  141: 
  142: /**************************************************************
  143:  * DECLARE
  144:  **************************************************************/
  145: /* static */
  146: static void stg_pio_read (struct stg_softc *, struct targ_info *, u_int);
  147: static void stg_pio_write (struct stg_softc *, struct targ_info *, u_int);
  148: static int stg_xfer (struct stg_softc *, u_int8_t *, int, int, int);
  149: static int stg_msg (struct stg_softc *, struct targ_info *, u_int);
  150: static int stg_reselected (struct stg_softc *);
  151: static int stg_disconnected (struct stg_softc *, struct targ_info *);
  152: static __inline void stg_pdma_end (struct stg_softc *, struct targ_info *);
  153: static int stghw_select_targ_wait (struct stg_softc *, int);
  154: static int stghw_check (struct stg_softc *);
  155: static void stghw_init (struct stg_softc *);
  156: static int stg_negate_signal (struct stg_softc *, u_int8_t, u_char *);
  157: static int stg_expect_signal (struct stg_softc *, u_int8_t, u_int8_t);
  158: static int stg_world_start (struct stg_softc *, int);
  159: static int stghw_start_selection (struct stg_softc *sc, struct slccb *);
  160: static void stghw_bus_reset (struct stg_softc *);
  161: static void stghw_attention (struct stg_softc *);
  162: static int stg_target_nexus_establish (struct stg_softc *);
  163: static int stg_lun_nexus_establish (struct stg_softc *);
  164: static int stg_ccb_nexus_establish (struct stg_softc *);
  165: static int stg_targ_init (struct stg_softc *, struct targ_info *, int);
  166: static __inline void stghw_bcr_write_1 (struct stg_softc *, u_int8_t);
  167: static int stg_timeout (struct stg_softc *);
  168: static void stg_selection_done_and_expect_msgout (struct stg_softc *);
  169: 
  170: struct scsi_low_funcs stgfuncs = {
  171: 	SC_LOW_INIT_T stg_world_start,
  172: 	SC_LOW_BUSRST_T stghw_bus_reset,
  173: 	SC_LOW_TARG_INIT_T stg_targ_init,
  174: 	SC_LOW_LUN_INIT_T NULL,
  175: 
  176: 	SC_LOW_SELECT_T stghw_start_selection,
  177: 	SC_LOW_NEXUS_T stg_lun_nexus_establish,
  178: 	SC_LOW_NEXUS_T stg_ccb_nexus_establish,
  179: 
  180: 	SC_LOW_ATTEN_T stghw_attention,
  181: 	SC_LOW_MSG_T stg_msg,
  182: 
  183: 	SC_LOW_TIMEOUT_T stg_timeout,
  184: 	SC_LOW_POLL_T stgintr,
  185: 
  186: 	NULL,
  187: };
  188: 
  189: /****************************************************
  190:  * hwfuncs
  191:  ****************************************************/
  192: static __inline void 
  193: stghw_bcr_write_1(sc, bcv)
  194: 	struct stg_softc *sc;
  195: 	u_int8_t bcv;
  196: {
  197: 
  198: 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, tmc_bctl, bcv);
  199: 	sc->sc_busimg = bcv;
  200: }
  201: 
  202: static int
  203: stghw_check(sc)
  204: 	struct stg_softc *sc;
  205: {
  206: 	struct scsi_low_softc *slp = &sc->sc_sclow;
  207: 	bus_space_tag_t iot = sc->sc_iot;
  208: 	bus_space_handle_t ioh = sc->sc_ioh;
  209: 	u_int fcbsize, fcb;
  210: 	u_int16_t lsb, msb;
  211: 
  212: 	lsb = bus_space_read_1(iot, ioh, tmc_idlsb);
  213: 	msb = bus_space_read_1(iot, ioh, tmc_idmsb);
  214: 	switch (msb << 8 | lsb)
  215: 	{
  216: 		case 0x6127:
  217: 			/* TMCCHIP_1800 not supported. (it's my policy) */
  218: 			sc->sc_chip = TMCCHIP_1800;
  219: 			return EINVAL;
  220: 
  221: 		case 0x60e9:
  222: 			if (bus_space_read_1(iot, ioh, tmc_cfg2) & 0x02)
  223: 			{
  224: 				sc->sc_chip = TMCCHIP_18C30;
  225: 				sc->sc_fsz = TMC18C30_FIFOSZ;
  226: 				fcbsize = TMC18C30_FCBSZ;
  227: 			}
  228: 			else
  229: 			{
  230: 				sc->sc_chip = TMCCHIP_18C50;
  231: 				sc->sc_fsz = TMC18C50_FIFOSZ;
  232: 				fcbsize = TMC18C50_FCBSZ;
  233: 			}
  234: 			break;
  235: 
  236: 		default:
  237: 			sc->sc_chip = TMCCHIP_UNK;
  238: 			return ENODEV;
  239: 	}
  240: 
  241: 	sc->sc_fcRinit = FCTL_INTEN;
  242: 	sc->sc_fcWinit = FCTL_PARENB | FCTL_INTEN;
  243: 
  244: 	if (slp->sl_cfgflags & CFG_NOATTEN)
  245: 		sc->sc_imsg = 0;
  246: 	else
  247: 		sc->sc_imsg = BCTL_ATN;
  248: 	sc->sc_busc = BCTL_BUSEN;
  249: 
  250: 	sc->sc_wthold = fcbsize + 256;
  251: 	sc->sc_rthold = fcbsize - 256;
  252: 	sc->sc_maxwsize = sc->sc_fsz;
  253: 
  254: 	fcb = fcbsize / (sc->sc_fsz / 16);
  255: 	sc->sc_icinit = ICTL_CD | ICTL_SEL | ICTL_ARBIT | fcb;
  256: 	return 0;
  257: }
  258: 
  259: static void
  260: stghw_init(sc)
  261: 	struct stg_softc *sc;
  262: {
  263: 	bus_space_tag_t iot = sc->sc_iot;
  264: 	bus_space_handle_t ioh = sc->sc_ioh;
  265: 
  266: 	bus_space_write_1(iot, ioh, tmc_ictl, 0);
  267: 	stghw_bcr_write_1(sc, BCTL_BUSFREE);
  268: 	bus_space_write_1(iot, ioh, tmc_fctl,
  269: 			  sc->sc_fcRinit | FCTL_CLRFIFO | FCTL_CLRINT);
  270: 	bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
  271: 	bus_space_write_1(iot, ioh, tmc_ictl, sc->sc_icinit);
  272: 
  273: 	bus_space_write_1(iot, ioh, tmc_ssctl, 0);
  274: }
  275: 
  276: static int
  277: stg_targ_init(sc, ti, action)
  278: 	struct stg_softc *sc;
  279: 	struct targ_info *ti;
  280: 	int action;
  281: {
  282: 	struct stg_targ_info *sti = (void *) ti;
  283: 
  284: 	if (action == SCSI_LOW_INFO_ALLOC || action == SCSI_LOW_INFO_REVOKE)
  285: 	{
  286: 		ti->ti_width = SCSI_LOW_BUS_WIDTH_8;
  287: 		ti->ti_maxsynch.period = 0;
  288: 		ti->ti_maxsynch.offset = 0;
  289: 		sti->sti_reg_synch = 0;
  290: 	}
  291: 	return 0;
  292: }	
  293: 
  294: /****************************************************
  295:  * scsi low interface
  296:  ****************************************************/
  297: static void
  298: stghw_attention(sc)
  299: 	struct stg_softc *sc;
  300: {
  301: 
  302: 	sc->sc_busc |= BCTL_ATN;
  303: 	sc->sc_busimg |= BCTL_ATN;
  304: 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, tmc_bctl, sc->sc_busimg);
  305: 	SCSI_LOW_DELAY(10);
  306: }
  307: 
  308: static void
  309: stghw_bus_reset(sc)
  310: 	struct stg_softc *sc;
  311: {
  312: 	bus_space_tag_t iot = sc->sc_iot;
  313: 	bus_space_handle_t ioh = sc->sc_ioh;
  314: 
  315: 	bus_space_write_1(iot, ioh, tmc_ictl, 0);
  316: 	bus_space_write_1(iot, ioh, tmc_fctl, 0);
  317: 	stghw_bcr_write_1(sc, BCTL_RST);
  318: 	SCSI_LOW_DELAY(100000);
  319: 	stghw_bcr_write_1(sc, BCTL_BUSFREE);
  320: }
  321: 
  322: static int
  323: stghw_start_selection(sc, cb)
  324: 	struct stg_softc *sc;
  325: 	struct slccb *cb;
  326: {
  327: 	bus_space_tag_t iot = sc->sc_iot;
  328: 	bus_space_handle_t ioh = sc->sc_ioh;
  329: 	struct targ_info *ti = cb->ti;
  330: 	u_int8_t stat;
  331: 	int s;
  332: 
  333: 	sc->sc_tmaxcnt = cb->ccb_tcmax * 1000 * 1000;
  334: 	sc->sc_dataout_timeout = 0;
  335: 	sc->sc_ubf_timeout = 0;
  336: 	stghw_bcr_write_1(sc, BCTL_BUSFREE);
  337: 	bus_space_write_1(iot, ioh, tmc_ictl, sc->sc_icinit);
  338: 
  339: 	s = splhigh();
  340: 	stat = bus_space_read_1(iot, ioh, tmc_astat);
  341: 	if ((stat & ASTAT_INT) != 0)
  342: 	{
  343: 		splx(s);
  344: 		return SCSI_LOW_START_FAIL;
  345: 	}
  346: 
  347: 	bus_space_write_1(iot, ioh, tmc_scsiid, sc->sc_idbit);
  348: 	bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit | FCTL_ARBIT);
  349: 	splx(s);
  350: 
  351: 	SCSI_LOW_SETUP_PHASE(ti, PH_ARBSTART);
  352: 	return SCSI_LOW_START_OK;
  353: }
  354: 
  355: static int
  356: stg_world_start(sc, fdone)
  357: 	struct stg_softc *sc;
  358: 	int fdone;
  359: {
  360: 	struct scsi_low_softc *slp = &sc->sc_sclow;
  361: 	int error;
  362: 
  363: 	if ((slp->sl_cfgflags & CFG_NOPARITY) == 0)
  364: 		sc->sc_fcRinit |= FCTL_PARENB;
  365: 	else
  366: 		sc->sc_fcRinit &= ~FCTL_PARENB;
  367: 
  368: 	if ((error = stghw_check(sc)) != 0)
  369: 		return error;
  370: 
  371: 	stghw_init(sc);
  372: 	scsi_low_bus_reset(slp);
  373: 	stghw_init(sc);
  374: 
  375: 	SOFT_INTR_REQUIRED(slp);
  376: 	return 0;
  377: }
  378: 
  379: static int
  380: stg_msg(sc, ti, msg)
  381: 	struct stg_softc *sc;
  382: 	struct targ_info *ti;
  383: 	u_int msg;
  384: {
  385: 	bus_space_tag_t iot = sc->sc_iot;
  386: 	bus_space_handle_t ioh = sc->sc_ioh;
  387: 	struct stg_targ_info *sti = (void *) ti;
  388: 	u_int period, offset;
  389: 
  390: 	if ((msg & SCSI_LOW_MSG_WIDE) != 0)
  391: 	{
  392: 		if (ti->ti_width != SCSI_LOW_BUS_WIDTH_8)
  393: 		{
  394: 			ti->ti_width = SCSI_LOW_BUS_WIDTH_8;
  395: 			return EINVAL;
  396: 		}
  397: 		return 0;
  398: 	}
  399: 
  400: 	if ((msg & SCSI_LOW_MSG_SYNCH) == 0)
  401: 		return 0;
  402: 
  403:  	period = ti->ti_maxsynch.period;
  404: 	offset = ti->ti_maxsynch.offset;
  405: 	period = period << 2;
  406: 	if (period >= 200)
  407: 	{
  408: 		sti->sti_reg_synch = (period - 200) / 50;
  409: 		if (period % 50)
  410: 			sti->sti_reg_synch ++;
  411: 		sti->sti_reg_synch |= SSCTL_SYNCHEN;
  412: 	}
  413: 	else if (period >= 100)
  414: 	{
  415: 		sti->sti_reg_synch = (period - 100) / 50;
  416: 		if (period % 50)
  417: 			sti->sti_reg_synch ++;
  418: 		sti->sti_reg_synch |= SSCTL_SYNCHEN | SSCTL_FSYNCHEN;
  419: 	}
  420: 	bus_space_write_1(iot, ioh, tmc_ssctl, sti->sti_reg_synch);
  421: 	return 0;
  422: }
  423: 
  424: /**************************************************************
  425:  * General probe attach
  426:  **************************************************************/
  427: int
  428: stgprobesubr(iot, ioh, dvcfg)
  429: 	bus_space_tag_t iot;
  430: 	bus_space_handle_t ioh;
  431: 	u_int dvcfg;
  432: {
  433: 	u_int16_t lsb, msb;
  434: 
  435: 	lsb = bus_space_read_1(iot, ioh, tmc_idlsb);
  436: 	msb = bus_space_read_1(iot, ioh, tmc_idmsb);
  437: 	switch (msb << 8 | lsb)
  438: 	{
  439: 		default:
  440: 			return 0;
  441: 		case 0x6127:
  442: 			/* not support! */
  443: 			return 0;
  444: 		case 0x60e9:
  445: 			return 1;
  446: 	}
  447: 	return 0;
  448: }
  449: 
  450: int
  451: stgprint(aux, name)
  452: 	void *aux;
  453: 	const char *name;
  454: {
  455: 
  456: 	if (name != NULL)
  457: 		printf("%s: scsibus ", name);
  458: 	return UNCONF;
  459: }
  460: 
  461: void
  462: stgattachsubr(sc)
  463: 	struct stg_softc *sc;
  464: {
  465: 	struct scsi_low_softc *slp = &sc->sc_sclow;
  466: 
  467: 	printf("\n");
  468: 
  469: 	sc->sc_idbit = (1 << slp->sl_hostid); 
  470: 	slp->sl_funcs = &stgfuncs;
  471: 	sc->sc_tmaxcnt = SCSI_LOW_MIN_TOUT * 1000 * 1000; /* default */
  472: 
  473: 	slp->sl_flags |= HW_READ_PADDING;
  474: 	slp->sl_cfgflags |= CFG_ASYNC;	/* XXX */
  475: 
  476: 	(void) scsi_low_attach(slp, 0, STG_NTARGETS, STG_NLUNS,
  477: 				sizeof(struct stg_targ_info), 0);
  478: }
  479: 
  480: /**************************************************************
  481:  * PDMA functions
  482:  **************************************************************/
  483: static __inline void
  484: stg_pdma_end(sc, ti)
  485: 	struct stg_softc *sc;
  486: 	struct targ_info *ti;
  487: {
  488: 	struct scsi_low_softc *slp = &sc->sc_sclow;
  489: 	bus_space_tag_t iot = sc->sc_iot;
  490: 	bus_space_handle_t ioh = sc->sc_ioh;
  491: 	struct slccb *cb = slp->sl_Qnexus;
  492: 	u_int len, tres;
  493: 
  494: 	slp->sl_flags &= ~HW_PDMASTART;
  495: 	sc->sc_icinit &= ~ICTL_FIFO;
  496: 	sc->sc_dataout_timeout = 0;
  497: 
  498: 	if (cb == NULL)
  499: 	{
  500: 		slp->sl_error |= PDMAERR;
  501: 		goto out;
  502: 	}
  503: 
  504: 	if (ti->ti_phase == PH_DATA)
  505: 	{
  506: 		len = bus_space_read_2(iot, ioh, tmc_fdcnt);
  507: 		if (slp->sl_scp.scp_direction == SCSI_LOW_WRITE)
  508: 		{
  509: 			if (len != 0)
  510: 			{
  511: 				tres = len + slp->sl_scp.scp_datalen;
  512: 				if (tres <= (u_int) cb->ccb_scp.scp_datalen)
  513: 				{
  514: 					slp->sl_scp.scp_data -= len;
  515: 					slp->sl_scp.scp_datalen = tres;
  516: 				}
  517: 				else
  518: 				{
  519: 					slp->sl_error |= PDMAERR;
  520: 					printf("%s len %x >= datalen %x\n",
  521: 						slp->sl_xname,
  522: 						len, slp->sl_scp.scp_datalen);
  523: 				}
  524: 			}
  525: 		}
  526: 		else if (slp->sl_scp.scp_direction == SCSI_LOW_READ)
  527: 		{
  528: 			if (len != 0)
  529: 			{
  530: 				slp->sl_error |= PDMAERR;
  531: 				printf("%s: len %x left in fifo\n",
  532: 					slp->sl_xname, len);
  533: 			}
  534: 		}
  535: 		scsi_low_data_finish(slp);
  536: 	}
  537: 	else
  538: 	{
  539: 
  540: 		printf("%s data phase miss\n", slp->sl_xname);
  541: 		slp->sl_error |= PDMAERR;
  542: 	}
  543: 
  544: out:
  545: 	bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
  546: }
  547: 
  548: static void
  549: stg_pio_read(sc, ti, thold)
  550: 	struct stg_softc *sc;
  551: 	struct targ_info *ti;
  552: 	u_int thold;
  553: {
  554: 	struct scsi_low_softc *slp = &sc->sc_sclow;
  555: 	bus_space_tag_t iot = sc->sc_iot;
  556: 	bus_space_handle_t ioh = sc->sc_ioh;
  557: 	struct sc_p *sp = &slp->sl_scp;
  558: 	int s, tout;
  559: 	u_int res;
  560: 	u_int8_t stat;
  561: 
  562: 	if ((slp->sl_flags & HW_PDMASTART) == 0)
  563: 	{
  564: 		bus_space_write_1(iot, ioh, tmc_fctl,
  565: 				  sc->sc_fcRinit | FCTL_FIFOEN);
  566: 		slp->sl_flags |= HW_PDMASTART;
  567: 	}
  568: 
  569: 	tout = sc->sc_tmaxcnt;
  570: 	while (tout -- > 0)
  571: 	{
  572: 		if (thold > 0)
  573: 		{
  574: 			s = splhigh();
  575: 			res = bus_space_read_2(iot, ioh, tmc_fdcnt);
  576: 			if (res < thold)
  577: 			{
  578: 				bus_space_write_1(iot, ioh, tmc_ictl,
  579: 						  sc->sc_icinit);
  580: 				splx(s);
  581: 				break;
  582: 			}
  583: 			splx(s);
  584: 		}
  585: 		else
  586: 		{
  587: 			stat = bus_space_read_1(iot, ioh, tmc_bstat);
  588: 			res = bus_space_read_2(iot, ioh, tmc_fdcnt);
  589: 			if (res == 0)
  590: 			{
  591: 				if ((stat & PHASE_MASK) != DATA_IN_PHASE)
  592: 					break;
  593: 				if (sp->scp_datalen <= 0)
  594: 					break;
  595: 				SCSI_LOW_DELAY(1);
  596: 				continue;
  597: 			}
  598: 		}
  599: 
  600: 		/* The assumtion res != 0 is valid here */
  601: 		if (res > sp->scp_datalen)
  602: 		{
  603: 			if (res == (u_int) -1)
  604: 				break;
  605: 
  606: 			slp->sl_error |= PDMAERR;
  607: 			if ((slp->sl_flags & HW_READ_PADDING) == 0)
  608: 			{
  609: 				printf("%s: read padding required\n",
  610: 					slp->sl_xname);
  611: 				break;
  612: 			}
  613: 
  614: 			sp->scp_datalen = 0;
  615: 			if (res > STG_MAX_DATA_SIZE)
  616: 				res = STG_MAX_DATA_SIZE;
  617: 			while (res -- > 0)
  618: 			{
  619: 				(void) bus_space_read_1(iot, ioh, tmc_rfifo);
  620: 			}
  621: 			continue;
  622: 		}
  623: 
  624: 		sp->scp_datalen -= res;
  625: 		if (res & 1)
  626: 		{
  627: 			*sp->scp_data = bus_space_read_1(iot, ioh, tmc_rfifo);
  628: 			sp->scp_data ++;
  629: 			res --;
  630: 		}
  631: 
  632: 		bus_space_read_multi_2(iot, ioh, tmc_rfifo,
  633: 				       (u_int16_t *) sp->scp_data, res >> 1);
  634: 		sp->scp_data += res;
  635: 	}
  636: 
  637: 	if (tout <= 0)
  638: 		printf("%s: pio read timeout\n", slp->sl_xname);
  639: }
  640: 
  641: static void
  642: stg_pio_write(sc, ti, thold)
  643: 	struct stg_softc *sc;
  644: 	struct targ_info *ti;
  645: 	u_int thold;
  646: {
  647: 	struct scsi_low_softc *slp = &sc->sc_sclow;
  648: 	bus_space_tag_t iot = sc->sc_iot;
  649: 	bus_space_handle_t ioh = sc->sc_ioh;
  650: 	struct sc_p *sp = &slp->sl_scp;
  651: 	u_int res;
  652: 	int s, tout;
  653: 	u_int8_t stat;
  654: 
  655: 	if ((slp->sl_flags & HW_PDMASTART) == 0)
  656: 	{
  657: 		stat = sc->sc_fcWinit | FCTL_FIFOEN | FCTL_FIFOW;
  658: 		bus_space_write_1(iot, ioh, tmc_fctl, stat | FCTL_CLRFIFO);
  659: 		bus_space_write_1(iot, ioh, tmc_fctl, stat);
  660: 		slp->sl_flags |= HW_PDMASTART;
  661: 	}
  662: 
  663: 	tout = sc->sc_tmaxcnt;
  664: 	while (tout -- > 0)
  665: 	{
  666: 		stat = bus_space_read_1(iot, ioh, tmc_bstat);
  667: 		if ((stat & PHASE_MASK) != DATA_OUT_PHASE)
  668: 			break;
  669: 
  670: 		if (sp->scp_datalen <= 0)
  671: 		{
  672: 			if (sc->sc_dataout_timeout == 0)
  673: 				sc->sc_dataout_timeout = SCSI_LOW_TIMEOUT_HZ;
  674: 			break;
  675: 		}
  676: 
  677: 		if (thold > 0)
  678: 		{
  679: 			s = splhigh();
  680: 			res = bus_space_read_2(iot, ioh, tmc_fdcnt);
  681: 			if (res > thold)
  682: 			{
  683: 				bus_space_write_1(iot, ioh, tmc_ictl,
  684: 						  sc->sc_icinit);
  685: 				splx(s);
  686: 				break;
  687: 			}
  688: 			splx(s);
  689: 		}
  690: 		else
  691: 		{
  692: 			res = bus_space_read_2(iot, ioh, tmc_fdcnt);
  693: 			if (res > sc->sc_maxwsize / 2)
  694: 			{
  695: 				SCSI_LOW_DELAY(1);
  696: 				continue;
  697: 			}
  698: 		}
  699: 			
  700: 		if (res == (u_int) -1)
  701: 			break;
  702: 		res = sc->sc_maxwsize - res;
  703: 		if (res > sp->scp_datalen)
  704: 			res = sp->scp_datalen;
  705: 
  706: 		sp->scp_datalen -= res;
  707: 		if ((res & 0x1) != 0)
  708: 		{
  709: 			bus_space_write_1(iot, ioh, tmc_wfifo, *sp->scp_data);
  710: 			sp->scp_data ++;
  711: 			res --;
  712: 		}
  713: 
  714: 		bus_space_write_multi_2(iot, ioh, tmc_wfifo, 
  715: 					(u_int16_t *) sp->scp_data, res >> 1);
  716: 		sp->scp_data += res;
  717: 	}
  718: 
  719: 	if (tout <= 0)
  720: 		printf("%s: pio write timeout\n", slp->sl_xname);
  721: }
  722: 
  723: static int
  724: stg_negate_signal(sc, mask, s)
  725: 	struct stg_softc *sc;
  726: 	u_int8_t mask;
  727: 	u_char *s;
  728: {
  729: 	struct scsi_low_softc *slp = &sc->sc_sclow;
  730: 	bus_space_tag_t bst = sc->sc_iot;
  731: 	bus_space_handle_t bsh = sc->sc_ioh;
  732: 	int wc;
  733: 	u_int8_t regv;
  734: 
  735: 	for (wc = 0; wc < STG_DELAY_MAX / STG_DELAY_INTERVAL; wc ++)
  736: 	{
  737: 		regv = bus_space_read_1(bst, bsh, tmc_bstat);
  738: 		if (regv == (u_int8_t) -1)
  739: 			return -1;
  740: 		if ((regv & mask) == 0)
  741: 			return 1;
  742: 
  743: 		SCSI_LOW_DELAY(STG_DELAY_INTERVAL);
  744: 	}
  745: 
  746: 	printf("%s: %s stg_negate_signal timeout\n", slp->sl_xname, s);
  747: 	return -1;
  748: }
  749: 
  750: static int
  751: stg_expect_signal(sc, phase, mask)
  752: 	struct stg_softc *sc;
  753: 	u_int8_t phase, mask;
  754: {
  755: 	struct scsi_low_softc *slp = &sc->sc_sclow;
  756: 	bus_space_tag_t bst = sc->sc_iot;
  757: 	bus_space_handle_t bsh = sc->sc_ioh;
  758: 	int wc;
  759: 	u_int8_t ph;
  760: 
  761: 	phase &= PHASE_MASK;
  762: 	for (wc = 0; wc < STG_DELAY_MAX / STG_DELAY_INTERVAL; wc ++)
  763: 	{
  764: 		ph = bus_space_read_1(bst, bsh, tmc_bstat);
  765: 		if (ph == (u_int8_t) -1)
  766: 			return -1;
  767: 		if ((ph & PHASE_MASK) != phase)
  768: 			return 0;
  769: 		if ((ph & mask) != 0)
  770: 			return 1;
  771: 
  772: 		SCSI_LOW_DELAY(STG_DELAY_INTERVAL);
  773: 	}
  774: 
  775: 	printf("%s: stg_expect_signal timeout\n", slp->sl_xname);
  776: 	return -1;
  777: }
  778: 
  779: static int
  780: stg_xfer(sc, buf, len, phase, clear_atn)
  781: 	struct stg_softc *sc;
  782: 	u_int8_t *buf;
  783: 	int len;
  784: 	int phase;
  785: 	int clear_atn;
  786: {
  787: 	bus_space_tag_t iot = sc->sc_iot;
  788: 	bus_space_handle_t ioh = sc->sc_ioh;
  789: 	int rv, ptr;
  790: 
  791: 	if (phase & BSTAT_IO)
  792: 		bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
  793: 	else
  794: 		bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcWinit);
  795: 
  796: 	for (ptr = 0; len > 0; len --)
  797: 	{
  798: 		rv = stg_expect_signal(sc, phase, BSTAT_REQ);
  799: 		if (rv <= 0)
  800: 			goto bad;
  801: 
  802: 		if (len == 1 && clear_atn != 0)
  803: 		{
  804: 			sc->sc_busc &= ~BCTL_ATN;
  805: 			stghw_bcr_write_1(sc, sc->sc_busc);
  806: 			SCSI_LOW_DEASSERT_ATN(&sc->sc_sclow);
  807: 		}
  808: 
  809: 		if (phase & BSTAT_IO)
  810: 		{
  811: 			buf[ptr ++] = bus_space_read_1(iot, ioh, tmc_rdata);
  812: 		}
  813: 		else
  814: 		{
  815: 			bus_space_write_1(iot, ioh, tmc_wdata, buf[ptr ++]);
  816: 		}
  817: 
  818: 		stg_negate_signal(sc, BSTAT_ACK, "xfer<ACK>");
  819: 	}
  820: 
  821: bad:
  822: 	bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
  823: 	return len;
  824: }
  825: 
  826: /**************************************************************
  827:  * disconnect & reselect (HW low)
  828:  **************************************************************/
  829: static int
  830: stg_reselected(sc)
  831: 	struct stg_softc *sc;
  832: {
  833: 	struct scsi_low_softc *slp = &sc->sc_sclow;
  834: 	bus_space_tag_t iot = sc->sc_iot;
  835: 	bus_space_handle_t ioh = sc->sc_ioh;
  836: 	int tout;
  837: 	u_int sid;
  838: 	u_int8_t regv;
  839: 
  840: 	if (slp->sl_selid != NULL)
  841: 	{
  842: 		/* XXX:
  843: 		 * Selection vs Reselection conflicts.
  844: 		 */
  845: 		bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
  846: 		stghw_bcr_write_1(sc, BCTL_BUSFREE);
  847: 	}
  848: 	else if (slp->sl_Tnexus != NULL)
  849: 	{
  850: 		printf("%s: unexpected termination\n", slp->sl_xname);
  851: 		stg_disconnected(sc, slp->sl_Tnexus);
  852: 	}
  853: 
  854: 	/* XXX:
  855: 	 * We should ack the reselection as soon as possible,
  856: 	 * because the target would abort the current reselection seq 
  857:   	 * due to reselection timeout.
  858: 	 */
  859: 	tout = STG_DELAY_SELECT_POLLING_MAX;
  860: 	while (tout -- > 0)
  861: 	{
  862: 		regv = bus_space_read_1(iot, ioh, tmc_bstat);
  863: 		if ((regv & (BSTAT_IO | BSTAT_SEL | BSTAT_BSY)) == 
  864: 			    (BSTAT_IO | BSTAT_SEL))
  865: 		{
  866: 			SCSI_LOW_DELAY(1);
  867: 			regv = bus_space_read_1(iot, ioh, tmc_bstat);
  868: 			if ((regv & (BSTAT_IO | BSTAT_SEL | BSTAT_BSY)) == 
  869: 				    (BSTAT_IO | BSTAT_SEL))
  870: 				goto reselect_start;
  871: 		}
  872: 		SCSI_LOW_DELAY(1);
  873: 	}
  874: 	printf("%s: reselction timeout I\n", slp->sl_xname);
  875: 	return EJUSTRETURN;
  876: 	
  877: reselect_start:
  878: 	sid = (u_int) bus_space_read_1(iot, ioh, tmc_scsiid);
  879: 	if ((sid & sc->sc_idbit) == 0)
  880: 	{
  881: 		/* not us */
  882: 		return EJUSTRETURN;
  883: 	}
  884: 
  885: 	bus_space_write_1(iot, ioh, tmc_fctl, 
  886: 			    sc->sc_fcRinit | FCTL_CLRFIFO | FCTL_CLRINT);
  887: 	bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
  888: 	stghw_bcr_write_1(sc, sc->sc_busc | BCTL_BSY);
  889: 
  890: 	while (tout -- > 0)
  891: 	{
  892: 		regv = bus_space_read_1(iot, ioh, tmc_bstat);
  893: 		if ((regv & (BSTAT_SEL | BSTAT_BSY)) == BSTAT_BSY)
  894: 			goto reselected;
  895: 		SCSI_LOW_DELAY(1);
  896: 	}
  897: 	printf("%s: reselction timeout II\n", slp->sl_xname);
  898: 	return EJUSTRETURN;
  899: 
  900: reselected:
  901: 	sid &= ~sc->sc_idbit;
  902: 	sid = ffs(sid) - 1;
  903: 	if (scsi_low_reselected(slp, sid) == NULL)
  904: 		return EJUSTRETURN;
  905: 
  906: #ifdef	STG_STATICS
  907: 	stg_statics.reselect ++;
  908: #endif	/* STG_STATICS */
  909: 	return EJUSTRETURN;
  910: }
  911: 
  912: static int
  913: stg_disconnected(sc, ti)
  914: 	struct stg_softc *sc;
  915: 	struct targ_info *ti;
  916: {
  917: 	struct scsi_low_softc *slp = &sc->sc_sclow;
  918: 	bus_space_tag_t iot = sc->sc_iot;
  919: 	bus_space_handle_t ioh = sc->sc_ioh;
  920: 
  921: 	/* clear bus status & fifo */
  922: 	bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit | FCTL_CLRFIFO);
  923: 	bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
  924: 	stghw_bcr_write_1(sc, BCTL_BUSFREE);
  925: 	sc->sc_icinit &= ~ICTL_FIFO;
  926: 	sc->sc_busc &= ~BCTL_ATN;
  927: 	sc->sc_dataout_timeout = 0;
  928: 	sc->sc_ubf_timeout = 0;
  929: 
  930: #ifdef	STG_STATICS
  931: 	stg_statics.disconnect ++;
  932: #endif	/* STG_STATICS */
  933: 	scsi_low_disconnected(slp, ti);
  934: 	return 1;
  935: }
  936: 
  937: /**************************************************************
  938:  * SEQUENCER
  939:  **************************************************************/
  940: static int
  941: stg_target_nexus_establish(sc)
  942: 	struct stg_softc *sc;
  943: {
  944: 	struct scsi_low_softc *slp = &sc->sc_sclow;
  945: 	bus_space_tag_t iot = sc->sc_iot;
  946: 	bus_space_handle_t ioh = sc->sc_ioh;
  947: 	struct targ_info *ti = slp->sl_Tnexus;
  948: 	struct stg_targ_info *sti = (void *) ti;
  949: 
  950: 	bus_space_write_1(iot, ioh, tmc_ssctl, sti->sti_reg_synch);
  951: 	if ((stg_io_control & STG_FIFO_INTERRUPTS) != 0)
  952: 	{
  953: 		sc->sc_icinit |= ICTL_FIFO;
  954: 	}
  955: 	return 0;
  956: }
  957: 
  958: static int
  959: stg_lun_nexus_establish(sc)
  960: 	struct stg_softc *sc;
  961: {
  962: 
  963: 	return 0;
  964: }
  965: 
  966: static int
  967: stg_ccb_nexus_establish(sc)
  968: 	struct stg_softc *sc;
  969: {
  970: 	struct scsi_low_softc *slp = &sc->sc_sclow;
  971: 	struct slccb *cb = slp->sl_Qnexus;
  972: 
  973: 	sc->sc_tmaxcnt = cb->ccb_tcmax * 1000 * 1000;
  974: 	return 0;
  975: }
  976: 
  977: #define	STGHW_SELECT_INTERVAL	10
  978: 
  979: static int
  980: stghw_select_targ_wait(sc, mu)
  981: 	struct stg_softc *sc;
  982: 	int mu;
  983: {
  984: 	bus_space_tag_t iot = sc->sc_iot;
  985: 	bus_space_handle_t ioh = sc->sc_ioh;
  986: 
  987: 	mu = mu / STGHW_SELECT_INTERVAL;
  988: 	while (mu -- > 0)
  989: 	{
  990: 		if ((bus_space_read_1(iot, ioh, tmc_bstat) & BSTAT_BSY) == 0)
  991: 		{
  992: 			SCSI_LOW_DELAY(STGHW_SELECT_INTERVAL);
  993: 			continue;
  994: 		}
  995: 		SCSI_LOW_DELAY(1);
  996: 		if ((bus_space_read_1(iot, ioh, tmc_bstat) & BSTAT_BSY) != 0)
  997: 		{
  998: 			return 0;
  999: 		}
 1000: 	}
 1001: 	return ENXIO;
 1002: }
 1003: 
 1004: static void
 1005: stg_selection_done_and_expect_msgout(sc)
 1006: 	struct stg_softc *sc;
 1007: {
 1008: 	struct scsi_low_softc *slp = &sc->sc_sclow;
 1009: 	bus_space_tag_t iot = sc->sc_iot;
 1010: 	bus_space_handle_t ioh = sc->sc_ioh;
 1011: 
 1012: 	bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit | FCTL_CLRFIFO);
 1013: 	bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
 1014: 	stghw_bcr_write_1(sc, sc->sc_imsg | sc->sc_busc);
 1015: 	SCSI_LOW_ASSERT_ATN(slp);
 1016: }
 1017: 
 1018: int
 1019: stgintr(arg)
 1020: 	void *arg;
 1021: {
 1022: 	struct stg_softc *sc = arg;
 1023: 	struct scsi_low_softc *slp = &sc->sc_sclow;
 1024: 	bus_space_tag_t iot = sc->sc_iot;
 1025: 	bus_space_handle_t ioh = sc->sc_ioh;
 1026: 	struct targ_info *ti;
 1027: 	struct physio_proc *pp;
 1028: 	struct buf *bp;
 1029: 	u_int derror, flags;
 1030: 	int len, s;
 1031: 	u_int8_t status, astatus, regv;
 1032: 
 1033: 	/*******************************************
 1034: 	 * interrupt check
 1035: 	 *******************************************/
 1036: 	if (slp->sl_flags & HW_INACTIVE)
 1037: 		return 0;
 1038: 
 1039: 	astatus = bus_space_read_1(iot, ioh, tmc_astat);
 1040: 	status = bus_space_read_1(iot, ioh, tmc_bstat);
 1041: 
 1042: 	if ((astatus & ASTAT_STATMASK) == 0 || astatus == (u_int8_t) -1)
 1043: 		return 0;
 1044: 
 1045: 	bus_space_write_1(iot, ioh, tmc_ictl, 0);
 1046: 	if (astatus & ASTAT_SCSIRST)
 1047: 	{
 1048: 		bus_space_write_1(iot, ioh, tmc_fctl,
 1049: 				  sc->sc_fcRinit | FCTL_CLRFIFO);
 1050: 		bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
 1051: 		bus_space_write_1(iot, ioh, tmc_ictl, 0);
 1052: 
 1053: 		scsi_low_restart(slp, SCSI_LOW_RESTART_SOFT, 
 1054: 				 "bus reset (power off?)");
 1055: 		return 1;
 1056: 	}
 1057: 
 1058: 	/*******************************************
 1059: 	 * debug section
 1060: 	 *******************************************/
 1061: #ifdef	STG_DEBUG
 1062: 	if (stg_debug)
 1063: 	{
 1064: 		scsi_low_print(slp, NULL);
 1065: 		printf("%s: st %x ist %x\n\n", slp->sl_xname,
 1066: 		       status, astatus);
 1067: #ifdef	DDB
 1068: 		if (stg_debug > 1)
 1069: 			SCSI_LOW_DEBUGGER("stg");
 1070: #endif	/* DDB */
 1071: 	}
 1072: #endif	/* STG_DEBUG */
 1073: 
 1074: 	/*******************************************
 1075: 	 * reselection & nexus
 1076: 	 *******************************************/
 1077: 	if ((status & RESEL_PHASE_MASK)== PHASE_RESELECTED)
 1078: 	{
 1079: 		if (stg_reselected(sc) == EJUSTRETURN)
 1080: 			goto out;
 1081: 	}
 1082: 
 1083: 	if ((ti = slp->sl_Tnexus) == NULL)
 1084: 		return 0;
 1085: 
 1086: 	derror = 0;
 1087: 	if ((astatus & ASTAT_PARERR) != 0 && ti->ti_phase != PH_ARBSTART &&
 1088: 	    (sc->sc_fcRinit & FCTL_PARENB) != 0)
 1089: 	{
 1090: 		slp->sl_error |= PARITYERR;
 1091: 		derror = SCSI_LOW_DATA_PE;
 1092: 		if ((status & PHASE_MASK) == MESSAGE_IN_PHASE)
 1093: 			scsi_low_assert_msg(slp, ti, SCSI_LOW_MSG_PARITY, 0);
 1094: 		else
 1095: 			scsi_low_assert_msg(slp, ti, SCSI_LOW_MSG_ERROR, 1);
 1096: 	}
 1097: 
 1098: 	/*******************************************
 1099: 	 * aribitration & selection
 1100: 	 *******************************************/
 1101: 	switch (ti->ti_phase)
 1102: 	{
 1103: 	case PH_ARBSTART:
 1104: 		if ((astatus & ASTAT_ARBIT) == 0)
 1105: 		{
 1106: #ifdef	STG_STATICS
 1107: 			stg_statics.arbit_fail_0 ++;
 1108: #endif	/* STG_STATICS */
 1109: 			goto arb_fail;
 1110: 		}
 1111: 
 1112: 		status = bus_space_read_1(iot, ioh, tmc_bstat);
 1113: 		if ((status & BSTAT_IO) != 0)
 1114: 		{
 1115: 			/* XXX:
 1116: 			 * Selection vs Reselection conflicts.
 1117: 			 */
 1118: #ifdef	STG_STATICS
 1119: 			stg_statics.arbit_fail_1 ++;
 1120: #endif	/* STG_STATICS */
 1121: arb_fail:
 1122: 			bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
 1123: 			stghw_bcr_write_1(sc, BCTL_BUSFREE);
 1124: 			scsi_low_arbit_fail(slp, slp->sl_Qnexus);
 1125: 			goto out;
 1126: 		}
 1127: 
 1128: 		/*
 1129: 		 * selection assert start.
 1130: 		 */
 1131: 		SCSI_LOW_SETUP_PHASE(ti, PH_SELSTART);
 1132: 		scsi_low_arbit_win(slp);
 1133: 
 1134: 		s = splhigh();
 1135: 		bus_space_write_1(iot, ioh, tmc_scsiid,
 1136: 				  sc->sc_idbit | (1 << ti->ti_id));
 1137: 		stghw_bcr_write_1(sc, sc->sc_imsg | sc->sc_busc | BCTL_SEL);
 1138: 		bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcWinit);
 1139: 		if ((stg_io_control & STG_WAIT_FOR_SELECT) != 0)
 1140: 		{
 1141: 			/* selection abort delay 200 + 100 micro sec */
 1142: 			if (stghw_select_targ_wait(sc, 300) == 0)
 1143: 			{
 1144: 				SCSI_LOW_SETUP_PHASE(ti, PH_SELECTED);
 1145: 				stg_selection_done_and_expect_msgout(sc);
 1146: 			}	
 1147: 		}
 1148: 		splx(s);
 1149: 		goto out;
 1150: 
 1151: 	case PH_SELSTART:
 1152: 		if ((status & BSTAT_BSY) == 0)
 1153: 		{
 1154: 			/* selection timeout delay 250 ms */
 1155: 			if (stghw_select_targ_wait(sc, 250 * 1000) != 0)
 1156: 			{
 1157: 				stg_disconnected(sc, ti);
 1158: 				goto out;
 1159: 			}
 1160: 		}
 1161: 
 1162: 		SCSI_LOW_SETUP_PHASE(ti, PH_SELECTED);
 1163: 		stg_selection_done_and_expect_msgout(sc);
 1164: 		goto out;
 1165: 
 1166: 	case PH_SELECTED:
 1167: 		if ((status & BSTAT_REQ) == 0)
 1168: 			goto out;
 1169: 		stg_target_nexus_establish(sc);
 1170: 		break;
 1171: 
 1172: 	case PH_RESEL:
 1173: 		if ((status & BSTAT_REQ) == 0)
 1174: 			goto out;
 1175: 
 1176: 		/* clear a busy line */
 1177: 		bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
 1178: 		stghw_bcr_write_1(sc, sc->sc_busc);
 1179: 		stg_target_nexus_establish(sc);
 1180: 		if ((status & PHASE_MASK) != MESSAGE_IN_PHASE)
 1181: 		{
 1182: 			printf("%s: unexpected phase after reselect\n",
 1183: 			       slp->sl_xname);
 1184: 			slp->sl_error |= FATALIO;
 1185: 			scsi_low_assert_msg(slp, ti, SCSI_LOW_MSG_ABORT, 1);
 1186: 			goto out;
 1187: 		}
 1188: 		break;
 1189: 	}
 1190: 
 1191: 	/*******************************************
 1192: 	 * data phase
 1193: 	 *******************************************/
 1194: 	if ((slp->sl_flags & HW_PDMASTART) && STG_IS_PHASE_DATA(status) == 0)
 1195: 	{
 1196: 		if (slp->sl_scp.scp_direction == SCSI_LOW_READ)
 1197: 			stg_pio_read(sc, ti, 0);
 1198: 
 1199: 		stg_pdma_end(sc, ti);
 1200: 	}
 1201: 
 1202: 	/*******************************************
 1203: 	 * scsi seq
 1204: 	 *******************************************/
 1205: 	switch (status & PHASE_MASK)
 1206: 	{
 1207: 	case COMMAND_PHASE:
 1208: 		if (stg_expect_signal(sc, COMMAND_PHASE, BSTAT_REQ) <= 0)
 1209: 			break;
 1210: 
 1211: 		SCSI_LOW_SETUP_PHASE(ti, PH_CMD);
 1212: 		if (scsi_low_cmd(slp, ti) != 0)
 1213: 		{
 1214: 			scsi_low_attention(slp);
 1215: 		}
 1216: 
 1217: 		if (stg_xfer(sc, slp->sl_scp.scp_cmd, slp->sl_scp.scp_cmdlen,
 1218: 			     COMMAND_PHASE, 0) != 0)
 1219: 		{
 1220: 			printf("%s: CMDOUT short\n", slp->sl_xname);
 1221: 		}
 1222: 		break;
 1223: 
 1224: 	case DATA_OUT_PHASE:
 1225: 		SCSI_LOW_SETUP_PHASE(ti, PH_DATA);
 1226: 		if (scsi_low_data(slp, ti, &bp, SCSI_LOW_WRITE) != 0)
 1227: 		{
 1228: 			scsi_low_attention(slp);
 1229: 		}
 1230: 
 1231: 		pp = physio_proc_enter(bp);
 1232: 		if ((sc->sc_icinit & ICTL_FIFO) != 0)
 1233: 			stg_pio_write(sc, ti, sc->sc_wthold);
 1234: 		else
 1235: 			stg_pio_write(sc, ti, 0);
 1236: 		physio_proc_leave(pp);
 1237: 		break;
 1238: 
 1239: 	case DATA_IN_PHASE:
 1240: 		SCSI_LOW_SETUP_PHASE(ti, PH_DATA);
 1241: 		if (scsi_low_data(slp, ti, &bp, SCSI_LOW_READ) != 0)
 1242: 		{
 1243: 			scsi_low_attention(slp);
 1244: 		}
 1245: 
 1246: 		pp = physio_proc_enter(bp);
 1247: 		if ((sc->sc_icinit & ICTL_FIFO) != 0)
 1248: 			stg_pio_read(sc, ti, sc->sc_rthold);
 1249: 		else
 1250: 			stg_pio_read(sc, ti, 0);
 1251: 		physio_proc_leave(pp);
 1252: 		break;
 1253: 
 1254: 	case STATUS_PHASE:
 1255: 		regv = stg_expect_signal(sc, STATUS_PHASE, BSTAT_REQ);
 1256: 		if (regv <= 0)
 1257: 			break;
 1258: 
 1259: 		SCSI_LOW_SETUP_PHASE(ti, PH_STAT);
 1260: 		regv = bus_space_read_1(iot, ioh, tmc_sdna);
 1261: 		if (scsi_low_statusin(slp, ti, regv | derror) != 0)
 1262: 		{
 1263: 			scsi_low_attention(slp);
 1264: 		}
 1265: 		if (regv != bus_space_read_1(iot, ioh, tmc_rdata))
 1266: 		{
 1267: 			printf("%s: STATIN: data mismatch\n", slp->sl_xname);
 1268: 		}
 1269: 		stg_negate_signal(sc, BSTAT_ACK, "statin<ACK>");
 1270: 		break;
 1271: 
 1272: 	case MESSAGE_OUT_PHASE:
 1273: 		if (stg_expect_signal(sc, MESSAGE_OUT_PHASE, BSTAT_REQ) <= 0)
 1274: 			break;
 1275: 
 1276: 		SCSI_LOW_SETUP_PHASE(ti, PH_MSGOUT);
 1277: 		flags = (ti->ti_ophase != ti->ti_phase) ? 
 1278: 				SCSI_LOW_MSGOUT_INIT : 0;
 1279: 		len = scsi_low_msgout(slp, ti, flags);
 1280: 
 1281: 		if (len > 1 && slp->sl_atten == 0)
 1282: 		{
 1283: 			scsi_low_attention(slp);
 1284: 		}
 1285: 
 1286: 		if (stg_xfer(sc, ti->ti_msgoutstr, len, MESSAGE_OUT_PHASE,
 1287: 			     slp->sl_clear_atten) != 0)
 1288: 		{
 1289: 			printf("%s: MSGOUT short\n", slp->sl_xname);
 1290: 		}
 1291: 		else
 1292: 		{
 1293: 			if (slp->sl_msgphase >= MSGPH_ABORT) 
 1294: 			{
 1295: 				stg_disconnected(sc, ti);
 1296: 			}
 1297: 		}
 1298: 		break;
 1299: 
 1300: 	case MESSAGE_IN_PHASE:
 1301: 		/* confirm phase and req signal */
 1302: 		if (stg_expect_signal(sc, MESSAGE_IN_PHASE, BSTAT_REQ) <= 0)
 1303: 			break;
 1304: 
 1305: 		SCSI_LOW_SETUP_PHASE(ti, PH_MSGIN);
 1306: 
 1307: 		/* read data with NOACK */
 1308: 		regv = bus_space_read_1(iot, ioh, tmc_sdna);
 1309: 
 1310: 		if (scsi_low_msgin(slp, ti, derror | regv) == 0)
 1311: 		{
 1312: 			if (scsi_low_is_msgout_continue(ti, 0) != 0)
 1313: 			{
 1314: 				scsi_low_attention(slp);
 1315: 			}
 1316: 		}
 1317: 
 1318: 		/* read data with ACK */
 1319: 		if (regv != bus_space_read_1(iot, ioh, tmc_rdata))
 1320: 		{
 1321: 			printf("%s: MSGIN: data mismatch\n", slp->sl_xname);
 1322: 		}
 1323: 
 1324: 		/* wait for the ack negated */
 1325: 		stg_negate_signal(sc, BSTAT_ACK, "msgin<ACK>");
 1326: 
 1327: 		if (slp->sl_msgphase != 0 && slp->sl_msgphase < MSGPH_ABORT)
 1328: 		{
 1329: 			stg_disconnected(sc, ti);
 1330: 		}
 1331: 		break;
 1332: 
 1333: 	case BUSFREE_PHASE:
 1334: 		printf("%s: unexpected disconnect\n", slp->sl_xname);
 1335: 		stg_disconnected(sc, ti);
 1336: 		break;
 1337: 
 1338: 	default:
 1339: 		slp->sl_error |= FATALIO;
 1340: 		printf("%s: unknown phase bus %x intr %x\n",
 1341: 			slp->sl_xname, status, astatus);
 1342: 		break;
 1343: 	}
 1344: 
 1345: out:
 1346: 	bus_space_write_1(iot, ioh, tmc_ictl, sc->sc_icinit);
 1347: 	return 1;
 1348: }
 1349: 
 1350: static int
 1351: stg_timeout(sc)
 1352: 	struct stg_softc *sc;
 1353: {
 1354: 	struct scsi_low_softc *slp = &sc->sc_sclow;
 1355: 	bus_space_tag_t iot = sc->sc_iot;
 1356: 	bus_space_handle_t ioh = sc->sc_ioh;
 1357: 	int tout, count;
 1358: 	u_int8_t status;
 1359: 
 1360: 	if (slp->sl_Tnexus == NULL)
 1361: 		return 0;
 1362: 
 1363: 	status = bus_space_read_1(iot, ioh, tmc_bstat);
 1364: 	if ((status & PHASE_MASK) == 0)
 1365: 	{
 1366: 		if (sc->sc_ubf_timeout ++ == 0)
 1367: 			return 0;
 1368: 
 1369: 		printf("%s: unexpected bus free detected\n", slp->sl_xname);
 1370: 		slp->sl_error |= FATALIO;
 1371: 		scsi_low_print(slp, slp->sl_Tnexus);
 1372: 		stg_disconnected(sc, slp->sl_Tnexus);
 1373: 		return 0;
 1374: 	}
 1375: 
 1376: 	switch (status & PHASE_MASK)
 1377: 	{
 1378: 	case DATA_OUT_PHASE:
 1379: 		if (sc->sc_dataout_timeout == 0)
 1380: 			break;
 1381: 		if ((status & BSTAT_REQ) == 0)
 1382: 			break;
 1383: 		if (bus_space_read_2(iot, ioh, tmc_fdcnt) != 0)
 1384: 			break;
 1385: 		if ((-- sc->sc_dataout_timeout) > 0)
 1386: 			break;	
 1387: 
 1388: 	        slp->sl_error |= PDMAERR;
 1389: 		if ((slp->sl_flags & HW_WRITE_PADDING) == 0)
 1390: 		{
 1391: 			printf("%s: write padding required\n",
 1392: 				slp->sl_xname);
 1393: 			break;
 1394: 		}	
 1395: 
 1396: 		bus_space_write_1(iot, ioh, tmc_ictl, 0);
 1397: 
 1398: 		tout = STG_DELAY_MAX;
 1399: 		while (tout --)
 1400: 		{
 1401: 			status = bus_space_read_1(iot, ioh, tmc_bstat);
 1402: 			if ((status & PHASE_MASK) != DATA_OUT_PHASE)
 1403: 				break;
 1404: 
 1405: 			if (bus_space_read_2(iot, ioh, tmc_fdcnt) != 0)
 1406: 			{
 1407: 				SCSI_LOW_DELAY(1);
 1408: 				continue;
 1409: 			}
 1410: 
 1411: 			for (count = sc->sc_maxwsize; count > 0; count --)
 1412: 				bus_space_write_1(iot, ioh, tmc_wfifo, 0);
 1413: 		}
 1414: 
 1415: 		status = bus_space_read_1(iot, ioh, tmc_bstat);
 1416: 		if ((status & PHASE_MASK) == DATA_OUT_PHASE)
 1417: 			sc->sc_dataout_timeout = SCSI_LOW_TIMEOUT_HZ;
 1418: 
 1419: 		bus_space_write_1(iot, ioh, tmc_ictl, sc->sc_icinit);
 1420: 		break;
 1421: 
 1422: 	default:
 1423: 		break;
 1424: 	}
 1425: 	return 0;
 1426: }