#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of archive 1 (of 3)."
# Contents:  681.c 681.h Makefile README cat.c dsk.c file.c io.c
#   perror.c queue.c queue.h saerrno.h safile.h saioctl.h satypes.h
#   so.h so.h.orig stdlib.h test.c tty.c
# Wrapped by budd@buit2 on Fri Jun  1 18:13:06 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 681.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"681.c\"
else
echo shar: Extracting \"681.c\" \(1475 characters\)
sed "s/^X//" >681.c <<'END_OF_681.c'
X# include "satypes.h"
X# include "saioctl.h"
X# include "681.h"
X
Xvoid
Xdb_fputc( c, n )
X    char c;
X    int n;
X{
X    volatile register struct csr *u;
X
X    u = UART(n);
X    while( !(u->DU_SRA & DU_SR_TXREADY) )
X	;
X    u->DU_TBA = c;
X}
X
Xvoid
Xdb_fgetc( c, n )
X    char c;
X    int n;
X{
X    volatile register struct csr *u;
X
X    u = UART(n);
X    while( !(u->DU_SRA & DU_SR_RXREADY) )
X	;
X    u->DU_TBA = c;
X}
X
Xvoid
Xdb_stty( n, sg )
X    int n;
X    struct sgttyb *sg;
X{
X    volatile register struct csr *u, *d;
X
X# define CLOCK 3686400			/* xtal freq */
X# define RATE    38400			/* rate wanted */
X# define DIV   (CLOCK/RATE/16)		/* get clock x 16 */
X
X    u = UART(n);
X    d = DUART(n);
X    u->DU_CRA  = DU_CR_MSC_RRCV;	/* reset rx */
X    u->DU_CRA  = DU_CR_MSC_RXMT;	/* reset tx */
X    u->DU_CRA  = DU_CR_MSC_RERR;	/* reset error status */
X    u->DU_MR1A = DU_MR1_8B|DU_MR1_ZERO;	/* no rts, 8 bits, no parity */
X    u->DU_MR2A = DU_MR2_1STOP;		/* no cts, 1 stop bit */
X    d->DU_ACR  = DU_ACR_SET2|DU_ACR_T_X; /* rate set 2 (19.2Kbps), timer/1 */
X    d->DU_CTUR = DIV >> 8;
X    d->DU_CTLR = DIV & 0xff;
X    u->DU_CSRA = (sg->sg_ispeed << 4) | sg->sg_ospeed;
X    /* enable rx/tx '92 rts */
X    u->DU_CRA  = DU_CR_ARTS|DU_CR_RCV_ENA|DU_CR_XMT_ENA;
X    u->DU_CRA  = DU_CR_RCV_ENA|DU_CR_XMT_ENA; /* enable rx/tx for '81 */
X    d->DU_OPCR = 0x00;			/* ensure rts mode set */
X    d->DU_OPRS = 0x03;			/* set rts (both channels) */
X}
X
Xint
Xdb_poll( n )
X    int n;
X{
X    return( POLL_681(n) );
X}
END_OF_681.c
if test 1475 -ne `wc -c <681.c`; then
    echo shar: \"681.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f 681.h -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"681.h\"
else
echo shar: Extracting \"681.h\" \(6382 characters\)
sed "s/^X//" >681.h <<'END_OF_681.h'
X/****************************************************************
X * 681.h
X *
X * defines for {mc,sn}{68,2}6{81,92} dual asynch recvr/transmitter
X *
X */
X
Xstruct csr {
X    char du_bytes[16];
X};
X
X/****************************************************************
X * register offsets (page 4-1)
X */
X
X# define DU_REG(x)	du_bytes[x]
X
X# define DU_MR1A	DU_REG(0)	/* RW mode register a part 1 */
X# define DU_MR2A	DU_REG(0)	/* RW mode register a part 2 */
X
X# define DU_SRA		DU_REG(1)	/* RO status register a */
X# define DU_CSRA	DU_REG(1)	/* WO clock status register a */
X
X# define DU_TESTA	DU_REG(2)	/* NEVER READ REGISTER 2!! */
X# define DU_CRA		DU_REG(2)	/* WO command register a */
X
X# define DU_RBA		DU_REG(3)	/* RO reciever buffer a */
X# define DU_TBA		DU_REG(3)	/* WO transmit buffer a */
X/*
X */
X# define DU_IPCR	DU_REG(4)	/* RO input port change register */
X# define DU_ACR		DU_REG(4)	/* WO auxilary control register */
X
X# define DU_ISR		DU_REG(5)	/* RO interrupt state register */
X# define DU_IMR		DU_REG(5)	/* WO interrupt mask register */
X
X# define DU_CMSB	DU_REG(6)	/* RO counter most sig bits */
X# define DU_CLSB	DU_REG(7)	/* RO counter least sig bits */
X
X# define DU_CTUR	DU_REG(6)	/* WO counter/timer upper register */
X# define DU_CTLR	DU_REG(7)	/* WO counter/timer upper register */
X/*
X */
X# define DU_MR1B	DU_REG(8)	/* RW mode register b part 1 */
X# define DU_MR2B	DU_REG(8)	/* RW mode register b part 2 */
X
X# define DU_SRB		DU_REG(9)	/* RO status register b */
X# define DU_CSRB	DU_REG(9)	/* WO clock status register b */
X
X# define DU_TESTB	DU_REG(10)	/* NEVER READ REGISTER 10!! */
X# define DU_CRB		DU_REG(10)	/* WO command register b */
X
X# define DU_RBB		DU_REG(11)	/* RO reciever buffer b */
X# define DU_TBB		DU_REG(11)	/* WO transmit buffer b */
X/*
X * 68k version only:
X */
X# define DU_IVR		DU_REG(12)	/* RW interrupt vector register */
X
X# define DU_IP		DU_REG(13)	/* RO input port (unlatched) */
X# define DU_OPCR	DU_REG(13)	/* WO output port config register */
X
X# define DU_STARTC	DU_REG(14)	/* RA start counter (addr. trigger) */
X# define DU_STOPC	DU_REG(15)	/* RA stop counter (addr trigger) */
X
X# define DU_OPRS	DU_REG(14)	/* WO WA? output port set */
X# define DU_OPRC	DU_REG(15)	/* WO WA? output port clear */
X
X/****************************************************************/
X/* bits in MR1A, MR1B */
X
X# define DU_MR1_RxRTS	0x80
X# define DU_MR1_FFULL	0x40
X# define DU_MR1_BLOCK	0x20
X
X# define DU_MR1_EVEN	(0x00|0)
X# define DU_MR1_ODD	(0x00|4)
X# define DU_MR1_ONE	0x08
X# define DU_MR1_ZERO	0x10
X# define DU_MR1_MDROP	0x18
X
X# define DU_MR1_5B	0
X# define DU_MR1_6B	1
X# define DU_MR1_7B	2
X# define DU_MR1_8B	3
X
X/****************************************************************/
X/* bits in MR2A, MR2B */
X
X# define DU_MR2_AECHO	0x40
X# define DU_MR2_LLOOP	0x80
X# define DU_MR2_RLOOP	0xc0
X
X# define DU_MR2_TxRTS	0x20
X# define DU_MR2_TxCTS	0x10
X
X# define DU_MR2_1STOP	0x07
X# define DU_MR2_2STOP	0x0f
X
X/****************************************************************/
X/* interrupt masks for IMR and ISR */
X# define DU_IN_INP	0x80		/* input ports */
X# define DU_IN_BKB	0x40		/* break b change */
X# define DU_IN_RXB	0x20		/* rx b ready/full */
X# define DU_IN_TXB	0x10		/* tx b ready */
X
X# define DU_IN_CTR	0x08		/* counter / timer */
X# define DU_IN_BKA	0x04		/* break a change */
X# define DU_IN_RXA	0x02		/* rx a ready/full */
X# define DU_IN_TXA	0x01		/* tx a ready */
X
X/****************************************************************/
X/* bits in SRA and SRB */
X# define DU_SR_BRK	0x80		/* break */
X# define DU_SR_EFRAME	0x40		/* framming error */
X# define DU_SR_EPAR	0x20		/* parity error */
X# define DU_SR_EOVER	0x10		/* overrun error */
X# define DU_SR_TXEMPTY	0x08		/* tx underrun error */
X# define DU_SR_TXREADY	0x04		/* tx ready */
X# define DU_SR_FFULL	0x02		/* rx fifo full */
X# define DU_SR_RXREADY	0x01		/* rx ready */
X
X# define DU_SR_ERRMASK	0xfa		/* error mask */
X
X/****************************************************************/
X/* bits in ACR */
X# define DU_ACR_SET2	    0x80	/* baud rate set 2 */
X
X# define DU_ACR_C_IP2	    0x00	/* counter, clock from IP2 */
X# define DU_ACR_C_TXCA	    0x10	/* counter, 1x tx A clock */
X# define DU_ACR_C_TXCB	    0x20	/* counter, 1x tx B clock */
X# define DU_ACR_C_X_16	    0x30	/* counter, xtal / 16 */
X# define DU_ACR_T_IP2       0x50	/* timer, clock from IP2 / 16 */
X# define DU_ACR_T_X	    0x60	/* timer, xtal / 1 */
X# define DU_ACR_T_X_16	    0x70	/* timer, xtal / 16 */
X
X# define DU_ACR_DIP3	0x08		/* delta IP3 /IRQ */
X# define DU_ACR_DIP2	0x04		/* delta IP2 /IRQ */
X# define DU_ACR_DIP1	0x02		/* delta IP1 /IRQ */
X# define DU_ACR_DIP0	0x01		/* delta IP0 /IRQ */
X
X/****************************************************************/
X/* bits in CRA / CRB */
X# define DU_CR_MSC_RMR	  0x10		/* reset MR pointer */
X# define DU_CR_MSC_RXMT	  0x20		/* reset transmitter */
X# define DU_CR_MSC_RRCV	  0x30		/* reset reciever */
X# define DU_CR_MSC_RERR	  0x40		/* reset error status */
X# define DU_CR_MSC_RBREAK 0x50		/* reset break change interrupt */
X# define DU_CR_MSC_BBREAK 0x60		/* begin break */
X# define DU_CR_MSC_EBREAK 0x70		/* end break */
X
X/* begin {68,2}692 commands */
X# define DU_CR_ARTS	0x80		/* Assert RTSN */
X# define DU_CR_NRTS	0x90		/* Negate RTSN */
X# define DU_CR_STIMEOUT	0xa0		/* set special timeout mode */
X# define DU_CR_RTIMEOUT	0xc0		/* reset special timeout mode */
X# define DU_CR_SPWRDOWN	0xe0		/* set power down mode */
X# define DU_CR_RPWRDOWN	0xf0		/* reset power down mode */
X/* end {68,2}692 commands */
X
X# define DU_CR_XMT_ENA	0x04
X# define DU_CR_XMT_DIS	0x08
X
X# define DU_CR_RCV_ENA	0x01
X# define DU_CR_RCV_DIS	0x02
X
X/****************************************************************/
X
X# define BASE	0x28000000
X# if 1
X# define UART(n)  ((volatile struct csr *)(BASE+0x10*n))
X# define DUART(n) ((volatile struct csr *)(BASE+0x20*(n/2)))
X# else /* not yet... */
X# define UART(ctlr,unit) ((volatile struct csr *)(BASE+(ctlr)*0x20+(unit)*0x10)
X# define DUART(ctlr)	 ((volatile struct csr *)(BASE+(ctlr)*0x20))
X# endif
X
X# define PUTC_681(c,n) {		\
X    volatile register struct csr *du;	\
X    du = UART(n);			\
X    while( !(du->DU_SRA & DU_SR_TXREADY) ) ; \
X    du->DU_TBA = c;			\
X}
X
X# define GETC_681(c,n) {		\
X    volatile register struct csr *du;	\
X    du = UART(n);			\
X    while( !(du->DU_SRA & DU_SR_RXREADY) ) ; \
X    c = du->DU_RBA;			\
X}
X
X# define POLL_681(n) (UART(n)->DU_SRA & DU_SR_RXREADY)
END_OF_681.h
if test 6382 -ne `wc -c <681.h`; then
    echo shar: \"681.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f Makefile -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"Makefile\"
else
echo shar: Extracting \"Makefile\" \(1471 characters\)
sed "s/^X//" >Makefile <<'END_OF_Makefile'
XCC=gcc
X################
X# avoid implcit declaration warnings (by not useing -Wall)
XW=-W -Wreturn-type -Wunused -Wswitch -Wshadow -Wpointer-arith -Wcast-qual
X# -Wall -Wwrite-strings  -ansi -pedantic
X################
XCFLAGS=-g $W -DKERNEL -DMINIX -DTEST
X
XLIB=	file.o tty.o 681.o dsk.o scsi_hi.o scsi_low.o minix.o\
X	test.o perror.o	queue.o
X
XL=	lib.a
X
Xcat:	cat.o $L
X	cc -o cat cat.o $L -Bstatic
X
X$L:	$(LIB)
X	ar cr $@ $?
X	ranlib $@
X
Xshar:
X	rm -f Part*
X	makekit README Makefile *.[ch] *.orig
X
Xdepend:
X	grep '^#[ 	]*include' *.c | grep -v '<' | \
X	sed -e 's/:[^"]*"\([^"]*\)".*/: \1/' \
X	    -e 's/\.c/.o/' \
X	    -e 's,../[a-zA-Z]*/,,' | \
X	awk ' { if ($$1 != prev) { print rec; rec = $$0; prev = $$1; } \
X		else { if (length(rec $$2) > 78) { print rec; rec = $$0; } \
X		       else rec = rec " " $$2 } } \
X	      END { print rec } ' > makedep
X	echo '$$r makedep' >>eddep
X	echo '/^# DO NOT DELETE THIS LINE/+1,$$d' >eddep
X	echo '$$r makedep' >>eddep
X	echo 'w' >>eddep
X	cp Makefile Makefile.bak
X	ed - Makefile < eddep
X	rm eddep makedep
X
X# DO NOT DELETE THIS LINE
X
X681.o: satypes.h saioctl.h 681.h
Xcat.o: satypes.h safile.h
Xdsk.o: satypes.h safile.h saerrno.h saioctl.h disklabel.h so.h stdlib.h
Xfile.o: stdlib.h satypes.h saioctl.h safile.h saerrno.h
Xio.o: so.h
Xminix.o: satypes.h saerrno.h safile.h stdlib.h disklabel.h
Xqueue.o: queue.h
Xscsi_hi.o: so.h stdlib.h
Xscsi_low.o: so.h stdlib.h
Xtest.o: satypes.h safile.h
Xtty.o: satypes.h saioctl.h safile.h saerrno.h stdlib.h 681.h
END_OF_Makefile
if test 1471 -ne `wc -c <Makefile`; then
    echo shar: \"Makefile\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f README -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"README\"
else
echo shar: Extracting \"README\" \(1346 characters\)
sed "s/^X//" >README <<'END_OF_README'
XHere is a first pass and a full scale standalone I/O system for the
XPC532.  It has NOT yet been tested running on real hardware (I'm still
Xmissing some parts!).
X
XIt features;
X*	a simple sgtty interface for ttys
X*	reads a 4.3 Tahoe style disklabel
X*	several disks/partitions can be open at once.
X*	the ability to read files from Minix filesystems.
X*	open/close/read/write/ioctl/lseek
X*	overkill: dup/dup2
X
XMissing;
X*	stdio functions!!!
X*	Initialization (ie; for a SASI floppy ctlr)
X*	ioctl's for disk label (keep labels in core)
X*	ioctl's for formatting!!
X
Xbugs/features;
X*	sgtty state is per FD (not device!!)
X*	Superblock is at (1k!) block 1.  This is dumb.
X	it should be at block zero and the boot block and label
X	should be accessed using the raw disk (partition 0).
X
XThe intended use is for boot roms, secondary bootstraps, standalone
Xcopy / disk utilities etc.
X
Xpathname syntax;
X
Xtt(n)		where n is 1-8 ie; tt(0)
X
Xsd(c,u,l,p)	raw disk, ctrlr c, unit u, lun l, partition p
X		partition 0 is magic, and always the entire raw disk.
X
XThe default is sd(1,0,0,0) (the DP8490 unit 0 lun 0 raw partition)
X
X
XIf the partition contains a filesystem (only minix currently
Xsupported) then a filename may follow (no leading slash needed);
Xsd(1,1,0,0)minix
X
X(perhaps unit and lun should be encoded into a single value the way
Xsun does (ie; unit*8 + lun)??)
X
END_OF_README
if test 1346 -ne `wc -c <README`; then
    echo shar: \"README\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f cat.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"cat.c\"
else
echo shar: Extracting \"cat.c\" \(439 characters\)
sed "s/^X//" >cat.c <<'END_OF_cat.c'
X# include "satypes.h"			/* for safile */
X# include "safile.h"			/* to get open/Xopen defines for test */
X
Xint
Xmain() {
X    char str[ 100 ];
X    int f, cc;
X
X    puts("Standalone Cat");
X
X    while( printf("\n: "), gets( str ) ) {
X	f = open( str, 0 );
X	if( f < 0 )
X	    perror( str );
X	else {
X# undef write
X	    while( (cc = read(f, str, sizeof(str))) > 0 )
X		write( 1, str, cc );
X	    close( f );
X	}
X    }
X    return( 0 );			/* be ANSI */
X}
END_OF_cat.c
if test 439 -ne `wc -c <cat.c`; then
    echo shar: \"cat.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f dsk.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"dsk.c\"
else
echo shar: Extracting \"dsk.c\" \(7215 characters\)
sed "s/^X//" >dsk.c <<'END_OF_dsk.c'
X/* disk driver for PC532 open/close/read/write standalone i/o system
X *
X * Phil Budne; May 1990
X *
X * BUG(?) Does not keep labels in core.
X *
X * This means the label is read on each call to open.  It also means
X * rewriting the label on disk effects the next open without doing any
X * ioctl's.  4.3 Tahoe drivers keep static arrays of labels. In our
X * case this would mean 2*8*8 labels or about 20K of static data.  An
X * alternative would be to have an array of pointers to malloc'ed
X * disklabels, since most entries will be NULL.
X *
X * DIOCxxxx ioctl's are not implemeted
X *
X * keep write-thru buffer cache (dev_t + abs block) to avoid extra
X * reads?
X */
X
X# include "satypes.h"
X# include "safile.h"
X# include "saerrno.h"
X# include "saioctl.h"			/* for disklabel.h */
X# include "disklabel.h"
X# include "so.h"
X# include "stdlib.h"
X
X# define UINF ((u_long)~0)
X
Xstruct diskdata {			/* raw disk... */
X    daddr_t first, last;		/* partition first block, last */
X};
X
X# define NCTLR 2
X# define NUNIT 8
X# define NLUN  8
X
X/* magic partition for whole disk.
X * On Vaxen and Suns this is 'c'
X * On Tahoes this it 'a'?
X */
X# define WHOLE	0			/* use 'a' for now... */
X
Xstatic int dskwrite(), dskread(), dskclose();
Xint dskopen();
X
Xstruct devsw dskdev =			/* raw disk.. */
X    { TY_DSK, dskopen, dskclose, dskread, dskwrite, ioerr };
X
X/* NOTE!!! ctlr ignored!!! perhaps take dev_t instead of ctlr/unit/lun? */
X
Xextern int sc_rdwt();
X# define SC_READ(blk, buf, blks, ctlr, unit, lun ) \
X    (sc_rdwt(DISK_READ, blk, buf, blks, unit, lun) == OK)
X
X# define SC_WRITE(blk, buf, blks, ctlr, unit, lun ) \
X    (sc_rdwt(DISK_WRITE, blk, buf, blks, unit, lun) == OK)
X
Xint					/* called from file systems! */
Xdskopen( struct file **fpp, char *name ) {
X    int ctlr, unit, lun, part;
X    struct disklabel *dp;
X    struct partition *pp;
X    u_char buf[DBLKSIZE];
X    int whole;				/* bool */
X
X    ctlr = CTLR((*fpp)->device);
X    if( ctlr < 0 || ctlr >= NCTLR )
X	ERR(ECTLR);
X
X    unit = UNIT((*fpp)->device);
X    if( unit < 0 || unit >= NUNIT )
X	ERR(EUNIT);
X
X    lun = LUN((*fpp)->device);
X    if( lun < 0 || lun >= NLUN )
X	ERR(ELUN);
X
X    /* do open on device? use return as handle for get/putblk */
X    /* check if valid device!? UNIT_SENSE? */
X
X# ifndef TEST
X    /* get label block */
X    if( !SC_READ( LABELSECTOR, buf, 1,
X		 CTLR((*fpp)->device),
X		 UNIT((*fpp)->device),
X		 LUN((*fpp)->device) ) )
X	ERR(ERDLAB);			/* cannot read label! */
X					/* might be bad device!! */
X
X    /* validate partition */
X    part = (*fpp)->part;
X    whole = part == WHOLE;
X    if( !whole && 
X       (part < 0 || part >= dp->d_npartitions || part >= MAXPARTITIONS) )
X	ERR(EPART);
X
X    /* check for label */
X    dp = (struct disklabel *)(buf+LABELOFFSET);
X    pp = dp->d_partitions + part;
X
X    /* look at checksum too? */
X    if( dp->d_magic != DISKMAGIC || dp->d_magic2 != DISKMAGIC ) {
X	if( !whole ) 
X	    ERR(EUNLAB);
X
X	/* cons up fake info for "WHOLE" disk */
X	pp->p_offset = 0;
X	pp->p_size = UINF;
X    }
X    else if( pp->p_offset == UINF )
X	ERR(EPART);
X
X    if( name == NULL || *name == EOS ) { /* no name... (raw disk) */
X	struct diskdata *dd;
X	u_long size;
X
X	dd = (struct diskdata *) malloc( sizeof( struct diskdata ) );
X	if( dd == NULL )
X	    ERR(EIO);			/* ? */
X	(*fpp)->data = dd;
X
X	(*fpp)->bsize = dp->d_secsize;
X	dd->first = pp->p_offset;
X	size = pp->p_size;
X	if( size == UINF )
X	    dd->last = dp->d_secperunit - pp->p_offset;	/* rest of disk */
X	else
X	    dd->last = dd->first + size - 1;
X	(*fpp)->end = dd->last;
X	return( 0 );
X    } /* no name */
X    else {				/* have name... */
X	/* pass pp or dp to f/s open ????? */
X
X	switch( pp->p_fstype ) {
X# ifdef BSDFFS
X	case FS_BSDFFS:
X	    return( bsdopen( fpp, name, pp ) ); /* should patch fp->devsw */
X# endif
X# ifdef MINIX
X	case FS_MINIX:
X	    return( minixopen( fpp, name, pp ) ); /* should patch fp->devsw */
X# endif
X	default:
X	    ERR(ENOFS);
X	}
X    } /* have name */
X# else
X    return( minixopen( fpp, name, dp ) ); /* should patch dp->devsw */
X# endif
X}
X
X/* raw disk read */
Xstatic int
Xdskread( struct file *fp, u_char *buf, int count ) {
X    u_char iobuf[ DBLKSIZE ];
X    int blk, rem, cc, boff;
X    int ctlr, unit, lun;
X    struct diskdata *dd;
X
X    ctlr = CTLR(fp->device);
X    unit = UNIT(fp->device);
X    lun  = LUN(fp->device);
X    dd = fp->data;
X
X    /* get first block to xfer */
X    blk = fp->pos / fp->bsize + dd->first;
X
X    /* initial check for past EOF */
X    if( blk > dd->last )
X	return( -1 );
X
X    rem = count;			/* check last block and adjust?? */
X
X    boff = fp->pos % fp->bsize;		/* check if not block aligned */
X    if( boff != 0 ) {
X	if( !SC_READ( blk, iobuf, 1, ctlr, unit, lun ) )
X	    return( -1 );
X
X	cc = count;			/* get entire count */
X	if( cc+boff > fp->bsize )	/* read extends past first block */
X	    cc = fp->bsize-boff;	/* get just partial size */
X	memcpy( buf, iobuf+boff, cc );	/* copy the bytes we wanr */
X
X	buf += cc;
X	rem -= cc;
X	blk++;
X    } /* initial partial block */
X
X    if( blk <= dd->last && rem >= fp->bsize ) {
X	int bc;
X
X	bc = rem / fp->bsize;		/* get entire block count */
X	if( bc + blk - 1 > dd->last )	/* watch for end of partition */
X	    bc = dd->last - blk;
X
X	/* inhale whole blocks */
X	if( !SC_READ( blk, buf, bc, ctlr, unit, lun ) )
X	    return( count - rem );
X	blk += bc;
X	cc = bc * fp->bsize;
X	rem -= cc;
X	buf += cc;
X    }
X
X    if( blk <= dd->last && rem > 0 ) { /* last partial block */
X	if( !SC_READ( blk, iobuf, 1, ctlr, unit, lun ) )
X	    return( -1 );
X
X	memcpy( buf, iobuf, rem );
X	rem = 0;
X    } /* initial partial block */
X    fp->pos += count - rem;
X    return( count - rem );
X}
X
X/* raw disk write */
Xstatic int
Xdskwrite( struct file *fp, u_char *buf, int count ) {
X    u_char iobuf[ DBLKSIZE ];
X    int blk, rem, cc, boff;
X    int ctlr, unit, lun;
X    struct diskdata *dd;
X
X    ctlr = CTLR(fp->device);
X    unit = UNIT(fp->device);
X    lun  = LUN(fp->device);
X    dd = fp->data;
X
X    /* get first block to xfer */
X    blk = fp->pos / fp->bsize + dd->first;
X
X    /* initial check for past EOF */
X    if( blk > dd->last )
X	return( -1 );
X
X    rem = count;			/* check last block and adjust?? */
X
X    boff = fp->pos % fp->bsize;		/* check if not block aligned */
X    if( boff != 0 ) {
X	if( !SC_READ( blk, iobuf, 1, ctlr, unit, lun ) )
X	    return( -1 );
X
X	cc = count;
X	if( cc+boff > fp->bsize )
X	    cc = fp->bsize-boff;
X	memcpy( iobuf+boff, buf, cc );
X
X	if( !SC_WRITE( blk, iobuf, 1, ctlr, unit, lun ) )
X	    return( -1 );
X
X	buf += cc;
X	rem -= cc;
X	blk++;
X    } /* initial partial block */
X
X    if( blk <= dd->last && rem >= fp->bsize ) {
X	int bc;
X
X	bc = rem / fp->bsize;
X	if( bc + blk - 1 > dd->last )
X	    bc = dd->last - blk;
X
X	/* write whole blocks */
X	if( !SC_WRITE( blk, buf, bc, ctlr, unit, lun ) )
X	    return( count - rem );
X	blk += bc;
X	cc = bc * fp->bsize;
X	rem -= cc;
X	buf += cc;
X    }
X
X    if( blk <= dd->last && rem > 0 ) { /* last partial block */
X	if( !SC_READ( blk, iobuf, 1, ctlr, unit, lun ) )
X	    return( count - rem );
X
X	memcpy( iobuf, buf, rem );
X
X	if( SC_WRITE( blk, iobuf, 1, ctlr, unit, lun ) )
X	    rem = 0;
X    } /* initial partial block */
X    fp->pos += count - rem;
X    return( count - rem );
X} /* dskwrite */
X
Xstatic int
Xdskclose( struct file *fp ) {
X    free( fp->data );
X    return( 0 );
X}
END_OF_dsk.c
if test 7215 -ne `wc -c <dsk.c`; then
    echo shar: \"dsk.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f file.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"file.c\"
else
echo shar: Extracting \"file.c\" \(6196 characters\)
sed "s/^X//" >file.c <<'END_OF_file.c'
X/*
X * open/close/read/write i/o system for PC532 libso
X * Phil Budne
X *
X * open takes dev(ctlr,unit,lun,part)path
X *
X * Perhaps follow Sun and encode unit and lun together into unit as unit*8+lun?
X */
X
X# define MAXFILE 16
X
X# define NULL 0
X# define EOS '\0'
X
X# include <ctype.h>
X# include "stdlib.h"
X# include "satypes.h"
X# include "saioctl.h"
X# include "safile.h"
X# include "saerrno.h"
X
X# define DEF_TTY "tt(0)"		/* stdin/out/err */
X
X# define DEF_TYPE  TY_DSK
X# define DEF_CTLR  1			/* DP8490 for now... */
X# define DEF_UNIT  0
X# define DEF_LUN   0
X# define DEF_PART  0
X
Xint errno;
Xstruct file *files[MAXFILE];
X
Xextern struct devsw ttydev, dskdev;
X
Xstruct devsw *devsw[] = {
X    &ttydev,
X    &dskdev,
X    NULL
X};
X
Xstatic struct devsw *
Xdevsearch( char *name ) {
X    register struct devsw **sw;
X
X    for( sw = devsw; *sw != NULL; sw++ )
X	if( strcmp( name, (*sw)->name ) == 0 )
X	    return( *sw );
X    return( NULL );
X}
X
Xstruct file *
Xnewfile(void) {
X    struct file *fp;
X
X    /* could use an array.... */
X    fp = (struct file *)malloc( sizeof( struct file ) );
X    fp->pos = 0L;
X    fp->end = -1L;
X
X    return( fp );
X}
X
Xvoid
Xfreefile( struct file *fp ) {
X    free( fp );
X}
X
Xstatic int
Xfirstfree(void) {
X    register f;
X
X    for( f = 0; f < MAXFILE; f++ )
X	if( files[f] == NULL )
X	    return( f );
X    return( -1 );
X}
X
Xvoid
Xreset(void) {				/* ala TOPS-10/20 */
X    int i;
X
X    for( i = 0; i < MAXFILE; i++ )
X	if( files[i] != NULL )
X	    close( i );
X
X    open(DEF_TTY, O_RDWR);
X    dup(0);
X    dup(0);
X}
X
Xint
Xioerr() {
X    ERR(EIO);
X}
X
Xint
Xionull() {
X    return(0);
X}
X
X/**************** "syscalls" from here on */
X
Xint
Xgetdtablesize(void) {
X    return( MAXFILE );
X}
X
Xint
Xread( int f, char *buf, int count ) {
X    register struct file *fp;
X
X    if( f < 0 || f >= MAXFILE ||
X       (fp = files[f]) == NULL || !(fp->flags&FREAD) )
X	ERR(EBADF);
X
X    return( (fp->devsw->read)( fp, buf, count ) );
X}
X
Xint
Xwrite( int f, char *buf, int count ) {
X    register struct file *fp;
X    int ret;
X
X    if( f < 0 || f >= MAXFILE ||
X       (fp = files[f]) == NULL || !(fp->flags&FWRITE) )
X	ERR(EBADF);
X
X    if( fp->flags&FAPPEND )
X	fp->pos = fp->end;
X
X    ret = (fp->devsw->write)( fp, buf, count );
X
X    if( fp->pos > fp->end )
X	fp->end = fp->pos;
X    return( ret );
X}
X
Xint
Xclose( int f ) {
X    int ret;
X    register struct file *fp;
X
X    if( f < 0 || f >= MAXFILE || (fp = files[f]) == NULL )
X	ERR(EBADF);
X
X    files[f] = NULL;			/* release fd */
X
X    if( --(fp->references) > 0 )	/* last ref? */
X	return( 0 );			/* no */
X
X    ret = (fp->devsw->close)( fp );
X    freefile( fp );
X    return( ret );
X}
X
Xint
Xioctl( int f, long cookie, void *buf ) {
X    register struct file *fp;
X
X    if( f < 0 || f >= MAXFILE || (fp = files[f]) == NULL )
X	ERR(EBADF);
X
X    return( (fp->devsw->control)( fp, cookie, buf ) );
X}
X
Xint
Xopen( char *name, int oflags, int mode ) {
X    int ctlr, unit, lun, part, flags, args[4], nargs, f;
X    register struct file *fp;
X    char type[32], *tp, *savename;
X    struct devsw *sw;
X
X    f = firstfree();			/* warning... race */
X    if( f < 0 )
X	ERR(EIO);			/* EMFILE */
X
X    flags = (mode & FMODE) | (oflags & FAPPEND|FCREAT|FEXCL);
X    switch( oflags & 3 ) {
X    case O_RDONLY:
X	flags |= FREAD;
X	break;
X    case O_WRONLY:
X	flags |= FWRITE;
X	break;
X    case O_RDWR:
X	flags |= FRDWR;
X	break;
X    }
X
X    ctlr  = DEF_CTLR;
X    unit  = DEF_UNIT;
X    lun   = DEF_LUN;
X    part  = DEF_PART;
X
X    tp = type;
X    savename = name;
X    while( *name && *name != '(' )
X	*tp++ = *name++;
X
X    if( *name == '(' ) {		/* get end of device? */
X	
X	/* parse (ctlr,unit,lun,part) */
X	name++;
X	nargs = 0;
X	while( nargs < 4 && *name && *name != ')' ) {
X	    int i, t;
X	    
X	    t = 0; i = 0;
X	    while( isdigit(*name) ) {
X		i = i * 10 + *name++ - '0';
X		t++;
X	    }
X	    if( t > 0 )			/* any digits? */
X		args[nargs++] = i;	/* yep, add to list */
X	    
X	    if( *name != ',' )
X		break;			/* while */
X	    name++;			/* skip comma */
X	}
X	
X	if( *name++ != ')' )
X	    ERR(ENXIO);
X    }
X    else {
X	strcpy( type, DEF_TYPE );	/* was not device... must be path */
X	name = savename;
X	nargs = 0;			/* default them all! */
X    }
X
X    sw = devsearch( type );
X    if( sw == NULL )
X	ERR(EADAPT);
X
X    switch( nargs ) {
X    case 0:				/* () */
X	break;
X    case 1:
X	part = args[0];			/* (part) */
X	break;
X    case 2:				/* (unit,part) */
X
X	unit = args[0];			/* beware!! not lun! */
X	part = args[1];
X	break;
X    case 3:				/* (unit,lun,part) */
X	unit = args[0];
X	lun  = args[1];
X	part = args[2];
X	break;
X    case 4:				/* (ctlr,unit,lun,part) */
X	ctlr = args[0];
X	unit = args[1];
X	lun  = args[2];
X	part = args[3];
X	break;
X    }
X
X    fp = newfile();
X    fp->device = MAKEDEV(ctlr, unit, lun);
X    fp->flags = flags;
X    fp->devsw = sw;
X    fp->part = part;
X    files[f] = fp;			/* race! */
X
X    if( (sw->open)( &files[f], name ) < 0 ) {
X	freefile( fp );
X	return( -1 );
X    }
X    fp->references++;
X    return( f );
X}
X
Xint
Xdup(int old) {
X    register struct file *fp;
X    int new;
X
X    if( old < 0 || old >= MAXFILE || (fp = files[old]) == NULL )
X	ERR(EBADF);
X
X    new = firstfree();
X    if( new < 0 )
X	ERR(EBADF);			/* EMFILE */
X
X    files[new] = fp;
X    fp->references++;
X    return( new );
X}
X
Xint
Xdup2(int old, int new) {
X    register struct file *fp;
X
X    if( old < 0 || old >= MAXFILE || (fp = files[old]) == NULL )
X	ERR(EBADF);
X
X    if( new < 0 || new >= MAXFILE )
X	ERR(EBADF);
X
X    /* both descriptors are legal.  No harm done yet */
X    if( files[new] != NULL && close(new) < 0 ) /* if new open, close it */
X	return( -1 );			/* propogate err */
X
X    files[new] = fp;
X    fp->references++;
X    return( new );			/* ? */
X}
X
Xoff_t
Xlseek( int f, off_t offset, int whence ) {
X    register struct file *fp;
X
X    if( f < 0 || f >= MAXFILE || (fp = files[f]) == NULL )
X	ERR(EBADF);
X
X    switch( whence ) {
X    case L_SET:
X	fp->pos = offset;
X	break;
X    case L_INCR:
X	fp->pos += offset;
X	break;
X    case L_XTND:			/* NYI */
X	if( fp->end != -1 ) {
X	    fp->pos = fp->end - offset;
X	    break;
X	}
X	/* fall */
X    default:
X	ERR(EIO);
X    }
X    return( fp->pos );
X}
X
Xvoid
Xpfile( struct file *fp ) {
X    dev_t dev;
X
X    dev = fp->device;
X    printf("(%d,%d,%d,%d)",
X	   fp->devsw->name,
X	   CTLR(dev), UNIT(dev), LUN(dev),
X	   fp->part );
X}
END_OF_file.c
if test 6196 -ne `wc -c <file.c`; then
    echo shar: \"file.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f io.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"io.c\"
else
echo shar: Extracting \"io.c\" \(812 characters\)
sed "s/^X//" >io.c <<'END_OF_io.c'
X#include "so.h"
X
X/*
X * Does Unix style mapping of cr to nl.  Probably should be used for all
X * terminal io rather than a direct db_fgetc().
X */
Xint getchar()
X{
X     int ret;
X
X     if ((ret = db_fgetc(DEFAULT_UART)) == '\r')
X	  return '\n';
X     else
X	  return ret;
X}
X
X/*
X * Converts nl to cr-lf, sends character to io.  Probably all other
X * routines want to use this as well.
X */
Xvoid putchar(x)
Xregister int x;
X{
X     if (x == '\n')
X	  db_fputc ('\r', DEFAULT_UART);
X     db_fputc(x, DEFAULT_UART);
X}
X
Xchar *gets(s)
Xregister char *s;
X{
X     register char ch;
X     register int idx = 0;
X
X     while ((ch = getchar()) != '\n') {
X	  s[idx++] = ch;
X	  putchar(ch);
X     }
X     putchar('\n');
X     s[idx] = '\0';
X     return(s);
X}
X
Xvoid puts(s)
Xregister char *s;
X{
X	while (*s)
X		putchar(*(s++));
X	putchar('\n');
X}
END_OF_io.c
if test 812 -ne `wc -c <io.c`; then
    echo shar: \"io.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f perror.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"perror.c\"
else
echo shar: Extracting \"perror.c\" \(100 characters\)
sed "s/^X//" >perror.c <<'END_OF_perror.c'
Xextern int errno;
X
Xvoid
Xperror( char *message ) {
X    printf("error %d: %s\n", errno, message );
X}
X
END_OF_perror.c
if test 100 -ne `wc -c <perror.c`; then
    echo shar: \"perror.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f queue.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"queue.c\"
else
echo shar: Extracting \"queue.c\" \(530 characters\)
sed "s/^X//" >queue.c <<'END_OF_queue.c'
X/* simulate vax queue instructions */
X
X# include "queue.h"
X
X/* sun supplies them as well! */
X# if !defined(vax)
Xvoid
Xinsque( register struct qelem *elem, register struct qelem *pred ) {
X    elem->q_forw = pred->q_forw;
X    elem->q_back = pred;
X    pred->q_forw->q_back = elem;
X    pred->q_forw = elem;
X}
X
Xvoid
Xremque( register struct qelem *elem ) {
X    elem->q_forw->q_back = elem->q_back;
X    elem->q_back->q_forw = elem->q_forw;
X}
X# endif
X
Xvoid
Xinique( register struct qelem *elem ) {
X    elem->q_forw = elem->q_back = elem;
X}
END_OF_queue.c
if test 530 -ne `wc -c <queue.c`; then
    echo shar: \"queue.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f queue.h -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"queue.h\"
else
echo shar: Extracting \"queue.h\" \(70 characters\)
sed "s/^X//" >queue.h <<'END_OF_queue.h'
Xstruct qelem {
X    struct qelem *q_forw;
X    struct qelem *q_back;
X};
END_OF_queue.h
if test 70 -ne `wc -c <queue.h`; then
    echo shar: \"queue.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f saerrno.h -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"saerrno.h\"
else
echo shar: Extracting \"saerrno.h\" \(1967 characters\)
sed "s/^X//" >saerrno.h <<'END_OF_saerrno.h'
X/*
X * Copyright (c) 1988 Regents of the University of California.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that the above copyright notice and this paragraph are
X * duplicated in all such forms and that any documentation,
X * advertising materials, and other materials related to such
X * distribution and use acknowledge that the software was developed
X * by the University of California, Berkeley.  The name of the
X * University may not be used to endorse or promote products derived
X * from this software without specific prior written permission.
X * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
X * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
X * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X *
X *	@(#)saerrno.h	7.2 (Berkeley) 6/29/88
X */
X
Xextern	int errno;	/* just like unix */
X
X/* error codes */
X#define	EADAPT	1	/* bad adaptor */
X#define	ECTLR	2	/* bad controller */
X#define	EUNIT	3	/* bad drive */
X#define	EPART	4	/* bad partition */
X#define	ERDLAB	5	/* can't read disk label */
X#define	EUNLAB	6	/* unlabeled disk */
X#define	ENXIO	7	/* bad device specification */
X#define	EBADF	8	/* bad file descriptor */
X#define	EOFFSET	9	/* relative seek not supported */
X#define	ESRCH	10	/* directory search for file failed */
X#define	EIO	11	/* generic error */
X#define	ECMD	12	/* undefined driver command */
X#define	EBSE	13	/* bad sector error */
X#define	EWCK	14	/* write check error */
X#define	EECC	15	/* uncorrectable ecc error */
X#define	EHER	16	/* hard error */
X/* budd: */
X#define ELUN	17	/* bad lun */
X#define EMFILE	18	/* too many files */
X#define ENOFS	19	/* no support for named files on fstype */
X#define ENOTDIR 20	/* path component not a dir */
X#define ENOENT  21	/* file not found */
X#define EACCES  22	/* access denied */
X#define EISDIR  23	/* path component not a dir */
X
Xextern int errno;
X# define ERR(n) { errno = n; return( -1 ); }
END_OF_saerrno.h
if test 1967 -ne `wc -c <saerrno.h`; then
    echo shar: \"saerrno.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f safile.h -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"safile.h\"
else
echo shar: Extracting \"safile.h\" \(1081 characters\)
sed "s/^X//" >safile.h <<'END_OF_safile.h'
X# ifdef TEST
X# define read Xread
X# define write Xwrite
X# define open Xopen
X# define close Xclose
X# define ioctl Xioctl
X# define lseek Xlseek
X# endif
X
X# define TY_TTY "tt"
X# define TY_DSK "sd"
X
X/* open args */
X# define O_RDONLY  0
X# define O_WRONLY  1
X# define O_RDWR    2
X# define O_APPEND  FAPPEND
X# define O_CREAT   FCREAT
X# define O_EXCL    FEXCL
X
X# define FMODE   000777			/* creation mode */
X# define FREAD	 001000
X# define FWRITE	 002000
X# define FRDWR	 (FREAD|FWRITE)
X# define FAPPEND 004000
X# define FCREAT  010000
X# define FEXCL   020000
X
Xstruct file {
X    dev_t device;
X    struct devsw *devsw;
X    off_t pos;				/* file pointer */
X    off_t end;
X    short bsize;			/* block size */
X    short flags;			/* Fxxx */
X    short part;				/* partition number */
X    short references;
X
X    void *data;				/* device data */
X};
X
Xstruct devsw {
X    char *name;
X    int (*open)();
X    int (*close)();
X    int (*read)();
X    int (*write)();
X    int (*control)();
X    /* init, stat, fstat? (FIOSTAT?) */
X};
X
Xint ioerr(), ionull();
X
X# define L_SET	0
X# define L_INCR	1
X# define L_XTND	2
END_OF_safile.h
if test 1081 -ne `wc -c <safile.h`; then
    echo shar: \"safile.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f saioctl.h -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"saioctl.h\"
else
echo shar: Extracting \"saioctl.h\" \(885 characters\)
sed "s/^X//" >saioctl.h <<'END_OF_saioctl.h'
X/* for disklabel.h; we don't care about the size or read/write bits */
X# define _IO(ch,n)	 (((ch)<<8)|(n))
X# define _IOR(ch,n,siz)	 _IO(ch,n)
X# define _IOW(ch,n,siz)	 _IO(ch,n)
X# define _IOWR(ch,n,siz) _IO(ch,n)
X
X/* device independant operations */
X/* # define FIOxxxx _IO('f',1) */
X
X/* terminal operations */
Xstruct sgttyb {
X    unsigned char sg_ispeed, sg_ospeed;
X    unsigned char sg_erase,  sg_kill;
X    short sg_flags;
X};
X
X#define TIOCGETP _IO('t',1)		/* gtty */
X#define TIOCSETP _IO('t',2)		/* stty */
X
X# define ECHO	01
X# define CRMOD	02
X# define RAW	04
X# define CRT	010			/* ala v7m */
X
X/* x681 rate set B */
X/* no B0 */
X# define B75	0
X# define B110	1
X# define B134	2
X# define B150	3
X# define B300	4
X# define B600	5
X# define B1200	6
X# define B2000	7
X# define B2400	8
X# define B4800	9
X# define B1800	10
X# define B9600	12
X# define B19200	13
X# define B38400 14			/* clock/timer */
END_OF_saioctl.h
if test 885 -ne `wc -c <saioctl.h`; then
    echo shar: \"saioctl.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f satypes.h -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"satypes.h\"
else
echo shar: Extracting \"satypes.h\" \(823 characters\)
sed "s/^X//" >satypes.h <<'END_OF_satypes.h'
X# define DEV_BSIZE 512			/* logical block size */
X
Xtypedef long daddr_t;
Xtypedef long off_t;
X
X/* for disklabel.h: */
X# define STANDALONE
Xtypedef unsigned long u_long;
Xtypedef unsigned short u_short;
Xtypedef unsigned char u_char;
X
X/* NOTE!! No "major" */
Xtypedef unsigned short dev_t;		/* 13 bits in use */
X
X# define MASK(n)	((1<<(n))-1)
X
X# define LUNSHIFT	0
X# define LUNBITS	3
X# define LUNMASK	MASK(LUNBITS)
X
X# define UNITSHIFT	(LUNSHIFT+LUNBITS)
X# define UNITBITS	3
X# define UNITMASK	MASK(UNITBITS)
X
X# define CTLRSHIFT	(UNITSHIFT+UNITBITS)
X# define CTLRBITS	1
X# define CTLRMASK	MASK(CTLRBITS)
X
X# define CTLR(d)	((d)>>CTLRSHIFT) & CTLRMASK
X# define UNIT(d)	((d)>>UNITSHIFT) & UNITMASK
X# define LUN(d)		((d)>> LUNSHIFT) & LUNMASK
X
X# define MAKEDEV(c,u,l) ((c)<<CTLRSHIFT | (u)<<UNITSHIFT | (l)<<LUNSHIFT)
X
X# define EOS '\0'
END_OF_satypes.h
if test 823 -ne `wc -c <satypes.h`; then
    echo shar: \"satypes.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f so.h -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"so.h\"
else
echo shar: Extracting \"so.h\" \(1559 characters\)
sed "s/^X//" >so.h <<'END_OF_so.h'
X#ifndef _SO_H_INCLUDE
X#define _SO_H_INCLUDE
X
X/* Definitions for standalone I/O lib */
X
X#define DUART0		0x28000000
X#define DUART1		0x28000020
X#define DUART2		0x28000040
X#define DUART3		0x28000060
X#define PARRDU		0x28000080
X#define PARCLU		0x280000A0
X#define SCSI_POLLED	0x30000000
X#define SCSI_DMA	0x38000000
X#define ICU_ADDR	0xFFFFFE00
X
X/* Which UART to use by default */
X#define DEFAULT_UART	0
X
X/* Which SCSI device to use by default */
X#define DEFAULT_SCSI_ADR	1
X#define DEFAULT_SCSI_LUN	0
X
X/* Low level scsi operation codes */
X#define DISK_READ	3
X#define DISK_WRITE	4
X
X/* The size of a disk block */
X#define DBLKSIZE	512
X
X/* Some disk address that will never be used */
X#define INSANE_BADDR	0x800000
X
Xstruct scsi_args {
X  long ptr [8];
X};
X
X#ifndef NULL
X#define NULL		0L
X#endif
X
X/*
X * The next macro defines where the "break" area in memory ends for
X * malloc() and friends. The area between edata and this address will
X * then be reserved and should not be used for anything else (or you will
X * no doubt have big problems). Depending on where your program's end-of-data
X * is, you may wish to locate this in such a way as to usurp a minimum
X * amount of memory.
X */
X#define BREAK_END_ADDR		((char *)0x400000)	/* to   4MB */
X
X/* Selectivly enable inline functions */
X#ifndef NO_INLINE
X#define Inline	inline
X#else
X#define Inline
X#endif
X 
Xextern void fatal(), warn();
Xextern long ulimit(int, long);
Xextern int brk(char *);
Xextern char *sbrk(int);
X
X/* budd.. moved here from scsi_{hi,lo}.h */
X#define OK 			0
X#define NOT_OK			OK+1
X
X#endif /* _SO_H_INCLUDE */
END_OF_so.h
if test 1559 -ne `wc -c <so.h`; then
    echo shar: \"so.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f so.h.orig -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"so.h.orig\"
else
echo shar: Extracting \"so.h.orig\" \(1499 characters\)
sed "s/^X//" >so.h.orig <<'END_OF_so.h.orig'
X#ifndef _SO_H_INCLUDE
X#define _SO_H_INCLUDE
X
X/* Definitions for standalone I/O lib */
X
X#define DUART0		0x28000000
X#define DUART1		0x28000020
X#define DUART2		0x28000040
X#define DUART3		0x28000060
X#define PARRDU		0x28000080
X#define PARCLU		0x280000A0
X#define SCSI_POLLED	0x30000000
X#define SCSI_DMA	0x38000000
X#define ICU_ADDR	0xFFFFFE00
X
X/* Which UART to use by default */
X#define DEFAULT_UART	0
X
X/* Which SCSI device to use by default */
X#define DEFAULT_SCSI_ADR	1
X#define DEFAULT_SCSI_LUN	0
X
X/* Low level scsi operation codes */
X#define DISK_READ	3
X#define DISK_WRITE	4
X
X/* The size of a disk block */
X#define DBLKSIZE	512
X
X/* Some disk address that will never be used */
X#define INSANE_BADDR	0x800000
X
Xstruct scsi_args {
X  long ptr [8];
X};
X
X#ifndef NULL
X#define NULL		0L
X#endif
X
X/*
X * The next macro defines where the "break" area in memory ends for
X * malloc() and friends. The area between edata and this address will
X * then be reserved and should not be used for anything else (or you will
X * no doubt have big problems). Depending on where your program's end-of-data
X * is, you may wish to locate this in such a way as to usurp a minimum
X * amount of memory.
X */
X#define BREAK_END_ADDR		((char *)0x400000)	/* to   4MB */
X
X/* Selectivly enable inline functions */
X#ifndef NO_INLINE
X#define Inline	inline
X#else
X#define Inline
X#endif
X 
Xextern void fatal(), warn();
Xextern long ulimit(int, long);
Xextern int brk(char *);
Xextern char *sbrk(int);
X
Xextern int sc_rdwt();
X
X#endif /* _SO_H_INCLUDE */
END_OF_so.h.orig
if test 1499 -ne `wc -c <so.h.orig`; then
    echo shar: \"so.h.orig\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f stdlib.h -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"stdlib.h\"
else
echo shar: Extracting \"stdlib.h\" \(498 characters\)
sed "s/^X//" >stdlib.h <<'END_OF_stdlib.h'
X/* sigh... */
X
Xint strcmp( char *, char * );
Xchar *strcpy( char *, char *);
X
Xunsigned char *memcpy( unsigned char *, unsigned char *, int);
Xint memcmp( unsigned char *, unsigned char *, int );
Xunsigned char *memset( unsigned char *, int, int );
X
Xvoid *malloc( int );
Xvoid free( void * );
X
Xint open( /* char *, int */ );
Xint close( int );
Xint read( int, char *, int );
Xint write( int, char *, int );
Xint ioctl( int, long, void * );
Xint dup( int );
Xint dup2( int, int );
X
Xvoid printf();				/* ugh */
END_OF_stdlib.h
if test 498 -ne `wc -c <stdlib.h`; then
    echo shar: \"stdlib.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f test.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"test.c\"
else
echo shar: Extracting \"test.c\" \(850 characters\)
sed "s/^X//" >test.c <<'END_OF_test.c'
X# ifdef TEST
X# include "satypes.h"
X# include "safile.h"
X# include <sys/syscall.h>
X
X# define TESTF "minixdisk"
X
X# undef open
X# undef close
X# undef read
X# undef write
X# undef lseek
X
Xint testopen();
Xstatic int testclose(), testread();
Xextern int ioerr();
X
Xstatic struct devsw testdev =
X    { "test", testopen, testclose, testread, ioerr, ioerr };
X
Xstatic int f, pos;			/* FIXME */
X
Xint
Xtestopen( struct file **fpp, u_char *name ) {
X    f = open( TESTF, 0 );
X    if( f < 0 )
X	return( -1 );
X
X    (*fpp)->devsw = &testdev;
X    pos = 0;
X    return( 0 );
X}
X
Xstatic int
Xtestread( struct file *fp, u_char *buf, int count ) {
X    int cc;
X
X    if( pos != fp->pos )
X	lseek( f, fp->pos, 0 );
X
X    cc = read( f, buf, count );
X    if( cc >= 0 )
X	pos = (fp->pos += cc);
X
X    return( cc );
X}
X
Xstatic int
Xtestclose( struct file *fp ) {
X    return close( f );
X}
X# endif
END_OF_test.c
if test 850 -ne `wc -c <test.c`; then
    echo shar: \"test.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f tty.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"tty.c\"
else
echo shar: Extracting \"tty.c\" \(5668 characters\)
sed "s/^X//" >tty.c <<'END_OF_tty.c'
X/* terminal driver for PC532 open/close/read/write standalone
X * i/o system -- simulates Un*x sgtty interface
X *
X * Phil Budne; May 1990
X *
X * TODO:
X * parity, cntrl echo, CRT kill, improve CRT erase
X * tchars (eof,brkc) ltchars (werasc,lnextc)
X * interupt driven?? start/stopc?
X */
X
X# include "satypes.h"
X# include "saioctl.h"
X# include "safile.h"
X# include "saerrno.h"
X# include "stdlib.h"
X
X# define CTRL(c) ((c)&037)
X/* purists might prefer @ and # */
X# define ERASE '\177'
X# define KILL  CTRL('U')
X
X# define EOT CTRL('D')			/* should be tchars.eof */
X# define LIT CTRL('V')			/* should be ltchars.lnextc */
X
X/* BUG/feature: ttydata is per fd (not per tty!)
X * could fix(?) by keeping an array of ttydata's
X * (or pointers there to)
X */
Xstruct ttydata {
X    struct sgttyb sgtty;
X    /* tchars?? buffers???? */
X};
X
X# define TD(fp) ((struct ttydata *)(fp->data))
X
X# define DEF_BAUD B9600
X
X/* basic device operations... assumes only one kind of tty device */
X# ifdef TEST
X# include <stdio.h>
X# define GETC(c,n) c = getchar()
X# define PUTC(c,n) putchar(c)
X# define POLL(n) 1
X# define STTY(n,m)
X# else
X# ifdef DBLIB				/* reduce code size! */
X# define GETC(c,n) c = db_fgetc(n)
X# define PUTC(c,n) db_fputc(c,n)
X# define POLL(n) db_poll(n)
X# else
X# include "681.h"
X# define GETC(c,n) GETC_681(c,n)
X# define PUTC(c,n) PUTC_681(c,n)
X# define POLL(n)   POLL_681(n)
X# endif
Xextern int db_stty();
X# define STTY(n,sg) db_stty(n,sg)
X# endif
X
X/**************** end basic operations */
X
X# define RAWTTYPUT(c,n) PUTC(n,n)	/* ignores CRMOD */
X
X/* output a character honoring CRMOD */
X# define TTYPUT(byte,n) {		\
X    register u_char _c = byte;		\
X    if( (_c == '\r' || _c == '\n') && (sg->sg_flags & CRMOD) ) { \
X	PUTC( '\r', n );		\
X	PUTC( '\n', n );		\
X    }					\
X    else				\
X	PUTC( _c, n );			\
X}
X
Xstatic int
X    ttyopen(), ttywrite(), ttyread(),
X    ttyclose(), ttycontrol(),
X    rawttywrite(), rawttyread();
X
Xstruct devsw ttydev =
X    { TY_TTY, ttyopen, ttyclose, ttyread, ttywrite, ioerr };
X
Xstruct devsw rttydev =
X    { "rtt", ttyopen, ttyclose, rawttyread, rawttywrite, ioerr };
X
Xstatic int
Xrawttywrite( struct file *fp, char *buf, int count ) {
X    int n, i;
X
X    n = fp->part;
X    i = count;
X    while( i-- > 0 )
X	RAWTTYPUT( *buf++, n );
X    return( count );
X}
X
Xstatic int
Xttywrite( struct file *fp, char *buf, int count ) { /* cooked output */
X    int n, i;
X    struct sgttyb *sg;
X
X    n = fp->part;
X    i = count;
X    sg = &TD(fp)->sgtty;		/* for TTYPUT */
X    while( i-- > 0 )
X	TTYPUT( *buf++, n );		/* honor CRMOD */
X    return( count );
X}
X
Xstatic int
Xrawttyread( struct file *fp, u_char *buf, int count ) {
X    int n, echo;
X    u_char *bp;
X
X    n = fp->part;
X    echo = TD(fp)->sgtty.sg_flags & ECHO;
X
X    while( POLL(n) && count-- > 0 ) {
X	u_char c;
X	GETC( c, n );
X	if( echo )
X	    RAWTTYPUT( c, n );
X	*bp++ = c;
X    }
X    return( bp - buf );
X}
X
Xstatic int
Xttyread( struct file *fp, u_char *buf, int count ) {
X    int n, ocount, echo;
X    struct sgttyb *sg;
X    u_char *bp, c;
X
X    /* note! uses user buffer for canonicalization */
X
X    n = fp->part;
X    ocount = count;
X    bp = buf;
X
X    sg = &TD(fp)->sgtty;
X    echo = sg->sg_flags & ECHO;
X    do {
X	GETC( c, n );
X
X	/* EOT must be on a line by itself! */
X	if( bp == buf && c == EOT )
X	    return( -1 );
X
X# ifdef TEST
X	if( c == 0xff ) {
X	    rewind( stdin );
X	    return( -1 );
X	}
X# endif
X
X	if( c == LIT )
X	    /* nothing! */;
X	else if( c == sg->sg_kill ) {
X	    /* CRT mode? */
X	    TTYPUT('\n', n);		/* honor CRMOD */
X	    count = ocount;		/* reset count */
X	    bp = buf;			/* reset buffer pointer */
X	    continue;
X	}
X	else if( c == sg->sg_erase ) {
X	    if( bp > buf ) {
X		bp--;
X		count++;
X		if( sg->sg_flags & CRT ) {
X		    /* needs work to handle ^CTRL and TAB */
X		    PUTC('\010', n);
X		    PUTC(' ',    n);
X		    PUTC('\010', n);
X		}
X		else {
X		    PUTC('\\', n );
X		    PUTC(*bp, n );
X		}
X	    }
X	    continue;
X	}
X	else if( c == '\r' && (sg->sg_flags & CRMOD) )
X	    c = '\n';
X	
X	if( echo ) {
X	    /* what about ctrl chars? */
X	    TTYPUT(c, n);
X	}
X	*bp++ = c;
X    } while( c != '\n' && --count > 0 ); /* can return before NL! */
X    return( bp - buf );
X}
X
Xstatic int
Xttycontrol( struct file *fp, long cookie, void *data ) {
X    struct sgttyb *sg;
X    struct ttydata *td;
X
X    td = TD(fp);
X    switch( cookie ) {
X    case TIOCGETP:
X	*(struct sgttyb *)data = td->sgtty; /* copy out... */
X	break;
X    case TIOCSETP:
X	sg = (struct sgttyb *)data;	/* get sgtty pointer */
X	if( sg->sg_ispeed > B38400 || sg->sg_ospeed > B38400 )
X	    ERR(EIO);
X	td->sgtty = *sg;		/* save new state (flags, chars) */
X	if( sg->sg_flags & RAW )	/* raw? */
X	    fp->devsw = &rttydev;	/* use raw operations */
X	else
X	    fp->devsw = &ttydev;	/* use cooked operations */
X	STTY( fp->part, sg );		/* set new speeds */
X	break;
X    default:
X	ERR(ECMD);
X    }
X    return( 0 );
X}
X
Xstatic int
Xttyopen( struct file **fpp, char *name ) {
X    int n;
X    struct sgttyb sg;
X    struct ttydata *td;
X
X
X    n = (*fpp)->part;
X    if( n != (n&7) )			/* must be from 0..7 */
X	ERR(EPART);
X
X    td = (struct ttydata *)malloc( sizeof( struct ttydata ) );
X    (*fpp)->data = td;
X
X    /* NOTE! set data via ioctl interface..
X     * (otherwise copies to self, and db_stty not called)
X     */
X    sg.sg_erase  = ERASE;
X    sg.sg_kill   = KILL;
X    sg.sg_ispeed = sg.sg_ospeed = DEF_BAUD;
X    sg.sg_flags  = ECHO|CRMOD|CRT;
X    ttycontrol( *fpp, TIOCSETP, &sg );	/* (re)set device */
X    return( 0 );
X}
X
Xstatic int
Xttyclose( struct file *fp ) {
X    free( fp->data );
X    return( 0 );
X}
X
Xint
Xstty( int fd, struct sgttyb *sg ) {
X    return( ioctl( fd, TIOCSETP, sg ) );
X}
X
Xint
Xgtty( int fd, struct sgttyb *sg ) {
X    return( ioctl( fd, TIOCGETP, sg ) );
X}
END_OF_tty.c
if test 5668 -ne `wc -c <tty.c`; then
    echo shar: \"tty.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of archive 1 \(of 3\).
cp /dev/null ark1isdone
MISSING=""
for I in 1 2 3 ; do
    if test ! -f ark${I}isdone ; then
	MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 3 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0
