sc.c

操作系统SunOS 4.1.3版本的源码

#include "sc.h"
#if	NSC > 0
#ifndef lint
static	char sccsid[] = "@(#)sc.c 1.1 92/07/30 SMI";
#endif

/*
 * Copyright (C) 1989, Sun Microsystems, Inc.
 */

/*
 *
 * TO DO:	1. reimplment PARITY support
 *		2. handle linked commands
 *
 */

#include <scsi/scsi.h>
#include <scsi/adapters/screg.h>
#include <sys/mman.h>
#include <machine/pte.h>
#include <machine/cpu.h>
#include <vm/seg.h>

/*
 * Definitions
 */

/*#define	SC_PARITY	/* Compile in (cough) Parity support */
/*#define	SC_LINKED	/* Compile in linked command support */
/*#define	SCDEBUG		/* Compile in debug code */

#ifdef	SC_PARITY
---- BLETCH ----- PARITY NOT SUPPORTED YET
#endif


#ifdef	SCDEBUG
#define	DEBUGGING	(scdebug || (scsi_options & SCSI_DEBUG_HA))
#define	DPRINTF(str)		if (DEBUGGING) sc_printf(sc, str)
#define	DPRINTF1(str, x)	if (DEBUGGING) sc_printf(sc, str, x)
#define	DPRINTF2(str, x, y)	if (DEBUGGING) sc_printf(sc, str, x, y)
#define	DPRINTF3(str, x, y, z)	if (DEBUGGING) sc_printf(sc, str, x, y, z)
#else
#define	DPRINTF
#define	DPRINTF1
#define	DPRINTF2
#define	DPRINTF3
#endif

#define	TRUE		1
#define	FALSE		0
#define	UNDEFINED	-1

#define	Tgt(sp)		((sp)->cmd_pkt.pkt_address.a_target)
#define	Lun(sp)		((sp)->cmd_pkt.pkt_address.a_lun)
#define	Nextcmd(sp)	((struct scsi_cmd *)((sp)->cmd_pkt.pkt_ha_private))

#define	CNAME	scdriver.mdr_cname
#define	CNUM	sc-sc_softc

#define	INTPENDING(reg) ((reg)->icr & (ICR_INTERRUPT_REQUEST | ICR_BUS_ERROR))


/*
 * SCSI Architecture Interface functions
 */

static int sc_start(), sc_abort(), sc_reset(), sc_getcap(), sc_setcap();

/*
 * Local && h/w related functions
 */


static void screset(), sc_watch(), sc_ustart(), sc_finish(), sc_abort_cmd();
static void sc_printf(), sc_flush();

/*
 * Local static data
 */

static struct scsitwo sc_softc[NSC];
static char *scbits =
	"\20\20Per\17Berr\16Odd\15IRQ\14REQ\13MSG\12CD\11IO\03Wrd\02Dma\01Ena";
static long sc_kment;
static int sc_mapins;

#ifdef	SCDEBUG
static int scdebug;
#endif	SCDEBUG

/*
 * External references
 */

extern struct seg kseg;

/*
 * Config dependencies
 */

static int scprobe(), scslave(), scattach(), scpoll();
int scintr();
struct	mb_driver scdriver = {
	scprobe, scslave, scattach, 0, 0, scpoll,
	sizeof (struct screg), "scsibus", 0, "sc", 0, MDR_BIODMA,
};

static int
scprobe(reg, ctlr)
caddr_t reg;
int ctlr;
{
	static char scwstart = 0;
	register struct scsitwo *sc;
	register struct screg *btmp = (struct screg *) reg;

	/* probe for different scsi host adaptor interfaces */
	if (peek((short *)&btmp->dma_count) == -1) {
		return (0);
	}
	/* validate ctlr by write/read/cmp with a data pattern */
	btmp->dma_count = 0x6789;
	if (btmp->dma_count != 0x6789) {
		return (0);
	}

	if (ctlr >= NSC) {
		printf("%s%d: illegal controller number", CNAME, ctlr);
		return (0);
	}

	sc_kment = rmalloc(kernelmap, mmu_btopr(MMU_PAGESIZE));
	if (sc_kment == 0)
		return (0);
	sc = &sc_softc[ctlr];
	sc->sc_reg = btmp;
	sc->sc_tran.tran_start 		= sc_start;
	sc->sc_tran.tran_abort		= sc_abort;
	sc->sc_tran.tran_reset		= sc_reset;
	sc->sc_tran.tran_getcap		= sc_getcap;
	sc->sc_tran.tran_setcap		= sc_setcap;
	sc->sc_tran.tran_pktalloc 	= scsi_std_pktalloc;
	sc->sc_tran.tran_dmaget		= scsi_std_dmaget;
	sc->sc_tran.tran_pktfree	= scsi_std_pktfree;
	sc->sc_tran.tran_dmafree	= scsi_std_dmafree;
	screset(sc, 0);
	if (!scwstart) {
		scwstart++;
		timeout (sc_watch, (caddr_t) 0, hz);
	}
	return (sizeof (struct screg));
}

/*ARGSUSED1*/
static int
scslave(md, reg)
struct mb_device *md;
caddr_t reg;
{
	struct scsitwo *sc = &sc_softc[md->md_unit];

	md->md_slave = HOST_ID << 3;
#ifndef	SC_LINKED
	/*
	 * Disable linked commands for the moment...
	 */
	if (scsi_options & SCSI_OPTIONS_LINK) {
		scsi_options ^= SCSI_OPTIONS_LINK;
		sc_printf(sc, "disabling linked command support\n");
	}
#endif
	return (1);
}

static int
scattach(md)
struct mb_device *md;
{
	int i;
	static int sc_spl = 0;
	struct scsitwo *sc = &sc_softc[md->md_unit];

	/*
	 * Calculate max spl value so far seen
	 */
	sc_spl = MAX(sc_spl, pritospl(md->md_intpri));

	/*
	 * Make sure that everyone, including us, is locking at
	 * the same priority.
	 */

	for (i = 0; i <= md->md_unit; i++) {
		sc_softc[i].sc_tran.tran_spl = sc_spl;
	}

	/*
	 * Initialize interrupt register
	 */
	if (md->md_mc->mc_intr) {
		/* set up for vectored interrupts */
		sc->sc_reg->intvec = md->md_mc->mc_intr->v_vec;
		*(md->md_mc->mc_intr->v_vptr) = (int) sc;
	} else {
		/* use auto-vectoring */
		sc->sc_reg->intvec = AUTOBASE + md->md_mc->mc_intpri;
	}
	/*
	 * Now make ourselves known to the rest of the SCSI world
	 */
	scsi_config(&sc->sc_tran, md);
}


/*
 *
 *	Begin of external interface routines
 *
 */

static int
sc_start(sp)
register struct scsi_cmd *sp;
{
	auto int s;
	register struct scsitwo *sc;
	register struct scsi_cmd *xp;

	sc = (struct scsitwo *) sp->cmd_pkt.pkt_address.a_cookie;
	s = splr(sc->sc_tran.tran_spl);
	if (xp = sc->sc_que) {
		for (;;) {
			if (Tgt(xp) == Tgt(sp) && Lun(xp) == Lun(sp)) {
				/* Queueing error */
				(void) splx(s);
				return (FALSE);
			}
			if (Nextcmd(xp) == 0)
				break;
			else
				xp = Nextcmd(xp);
		}
		Nextcmd(xp) = sp;
	} else {
		sc->sc_que = sp;
	}
	Nextcmd(sp) = 0;

	/*
	 * reinitialize some fields that need it...
	 */

	sp->cmd_pkt.pkt_resid = 0;
	sp->cmd_pkt.pkt_reason = sp->cmd_pkt.pkt_state =
		sp->cmd_pkt.pkt_statistics = 0;
	sp->cmd_cdbp = (caddr_t) sp->cmd_pkt.pkt_cdbp;
	sp->cmd_scbp = sp->cmd_pkt.pkt_scbp; *sp->cmd_scbp = 0;
	if (sp->cmd_timeout = sp->cmd_pkt.pkt_time)
		sp->cmd_flags |= CFLAG_WATCH;
	else
		sp->cmd_flags &= ~CFLAG_WATCH;
	sp->cmd_data = sp->cmd_saved_data = sp->cmd_mapping;
	sp->cmd_cursubseg = &sp->cmd_subseg;
	sp->cmd_subseg.d_base = sp->cmd_mapping;
	sp->cmd_subseg.d_count = 0;
	sp->cmd_subseg.d_next = (struct dataseg *) 0;
	sp->cmd_flags &= ~(CFLAG_NEEDSEG|CFLAG_CMDDISC);



	/*
	 * Okay- if this command is a polling command,
	 * and we're not the head of the queue, we have to
	 * wait for the commands ahead of us to finish.
	 */
	if (sp->cmd_pkt.pkt_flags & FLAG_NOINTR) {
		int id;
		while (sc->sc_que != sp) {
			DPRINTF ("polled command waiting\n");
			sc_dopoll(sc, sc->sc_cmdid);
		}
		id = sc->sc_cmdid;
		DPRINTF1 ("starting polling cmd #%d\n", id);
		sc_ustart(sc);
		DPRINTF ("waiting polled cmd completion\n");
		sc_dopoll(sc, id);
		DPRINTF1 ("polled cmd #%d complete\n", id);
		if (sc->sc_que)
			sc_ustart(sc);
	} else if (sc->sc_que == sp) {
		sc_ustart(sc);
	}
	(void) splx(s);
	return (TRUE);
}

/*ARGSUSED*/
static int
sc_abort(ap, pkt)
struct scsi_address *ap;
struct scsi_pkt *pkt;
{
	if (pkt != (struct scsi_pkt *) 0)
		return (FALSE);
	else
		return (FALSE);
}

static int
sc_reset(ap, level)
struct scsi_address *ap;
int level;
{
	struct scsitwo *sc = (struct scsitwo *) ap->a_cookie;
	struct scsi_cmd *sp = sc->sc_que;

	screset(sc, 0);

	if (sp) {
		/*
		 * If we're resetting everything, remove
		 * the current wait queue from reconsideration
		 * after we reset and blow away the current
		 * command.
		 */

		if (level == RESET_ALL) {
			sp = Nextcmd(sc->sc_que);
			Nextcmd(sc->sc_que) = 0;
		}

		sp->cmd_pkt.pkt_reason = CMD_RESET;
		sc_finish(sc);

		/*
		 * walk down the unrooted wait queue, 'finishing' off
		 * all the commands therein...
		 */
		if (level == RESET_ALL) {
			while (sp) {
				struct scsi_cmd *xp;
				xp = Nextcmd(sp);
				sp->cmd_pkt.pkt_reason = CMD_RESET;
				(*sp->cmd_pkt.pkt_comp)(sp);
				sp = xp;
			}
		}
		return (TRUE);
	} else {
		return (FALSE);
	}
}

/*ARGSUSED*/
static int
sc_getcap(ap, cap)
struct scsi_address *ap;
char *cap;
{
	if (cap == (char *) 0)
		return (UNDEFINED);
	else if (strncmp("dma_max", cap, 7) == 0)
		return (1<<16);
	else if (strncmp("msg_out", cap, 7) == 0)
		return (0);
	else if (strncmp("disconnect", cap, 10) == 0)
		return (0);
	else if (strncmp("synchronous", cap, 11) == 0)
		return (0);
	else if (strncmp("parity", cap, 6) == 0)
		return (0);
	else if (strncmp("initiator-id", cap, 12) == 0)
		return (HOST_ID);
	else
		return (UNDEFINED);
}

/*ARGSUSED*/
static int
sc_setcap(ap, cap, value)
struct scsi_address *ap;
char *cap;
int value;
{
	/*
	 * Cannot set any values yet
	 */
	return (UNDEFINED);
}



/*
 *
 * Internal start routine
 *
 */

static void
sc_ustart(sc)
register struct scsitwo *sc;
{
	register i;
	register struct scsi_cmd *sp = sc->sc_que;
	char dkn;
	int r;

	if (!sp)
		return;
	else if ((dkn = sp->cmd_pkt.pkt_pmon) >= 0) {
		dk_busy |= (1<<dkn);
		dk_xfer[dkn]++;
		if ((sp->cmd_flags & CFLAG_DMASEND) == 0)
			dk_read[dkn]++;
		dk_wds[dkn] += sp->cmd_dmacount >> 6;
	}

	/*
	 * sc_select will wait for the scsi bus to be free, attempt
	 * to select the target, will set up the dma engine for any
	 * possible dma transfer, and will set the icr bits for having
	 * interrupts enabled if this is an interrupting command.
	 *
	 */

	sc->sc_busy = 1;
	if (sc_select(sc) == FALSE) {
		sc_finish(sc);
		return;
	}

	/*
	 * At this point, we should either ge into STATUS phase or into
	 * COMMAND phase.
	 */
#ifdef	SCDEBUG
	if (DEBUGGING) {
		sc_printf(sc, "%d.%d cmd=", Tgt(sp), Lun(sp));
		for (i = 0; i < sp->cmd_cdblen; i++) {
			printf(" 0x%x", sp->cmd_cdbp[i]);
		}
		printf("\n");
	}
#endif	SCDEBUG
	for (r = i = 0; i < sp->cmd_cdblen; i++) {
		if ((r = sc_putbyte(sc, ICR_COMMAND, sp->cmd_cdbp[i])) <= 0) {
			break;
		}
	}
	if (r < 0) {
		sc_printf(sc, "couldn't send command\n");
		sc_abort_cmd(sc);
	} else if (i > 0) {
		sp->cmd_pkt.pkt_state |= STATE_SENT_CMD;
		sp->cmd_cdbp = (caddr_t) (((u_long)sp->cmd_cdbp) + i);
	}
	/*
	 * We will either let interrupts drive us the rest of the
	 * way, or call a polling routine to do that for us
	 */
}

static int