## diffname power/devhs.c 1990/0227
## diff -e /dev/null /n/bootesdump/1990/0227/sys/src/9/mips/devhsvme.c
0a
#include	"u.h"
#include	"lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#include	"errno.h"
#include	"devtab.h"

#include	"io.h"

enum {
	Maxtxburst=	1024,		/* maximum transmit burst size */
	Vmevec=		0xd0,		/* vme vector for interrupts */
	Intlevel=	5,		/* level to interrupt on */
};

struct hsvmestats {
	ulong	parity;
	ulong	rintr;
	ulong	tintr;
} hsvmestats;

#define ALIVE		0x0001
#define IENABLE		0x0004
#define EXOFLOW		0x0008
#define IRQ		0x0010
#define EMUTE		0x0020
#define EPARITY		0x0040
#define EFRAME		0x0080
#define EROFLOW		0x0100
#define REF		0x0800
#define XFF		0x4000
#define XHF		0x8000

#define FORCEW		0x0008
#define IPL(x)		((x)<<5)
#define NORESET		0xFF00
#define RESET		0x0000

#define CTL		0x0100
#define CHNO		0x0200
#define TXEOD		0x0400
#define NND		0x8000

Rendez hsvmer;

#define DELAY(n)	{ \
	register int N = 12*(n); \
	while (--N > 0); \
	}

static void hsvmeintr(int);

void
hsvmerestart(struct hsvme *addr)
{
	addr->csr = RESET;
	wbflush();
	DELAY(20000);

	/*
	 *  set interrupt vector
	 *  turn on addrice
	 *  set forcew to a known value
	 *  interrupt on level `Intlevel'
	 */
	addr->vector = 0xd0;
	addr->csr = NORESET|IPL(Intlevel)|IENABLE|ALIVE;
	wbflush();
	DELAY(500);
	addr->csr = NORESET|IPL(Intlevel)|FORCEW|IENABLE|ALIVE;
	wbflush();
	DELAY(500);
}

void
hsvmereset(void)
{
	struct hsvme *addr;

	addr = HSVME;
	addr->csr = RESET;
	wbflush();
	DELAY(20000);

	/*
	 *  routine to call on interrupt
	 */
	setvmevec(Vmevec, hsvmeintr);
}

void
hsvmeinit(void)
{
}

/*
 *  enable the device for interrupts
 */
static int
never(void *arg)
{
	return 0;
}
Chan*
hsvmeattach(char *spec)
{
	struct hsvme *addr;

	addr = HSVME;
	hsvmerestart(addr);
	print("hsvme csr %ux\n", addr->csr);

	return devattach('h', spec);
}

Chan*
hsvmeclone(Chan *c, Chan *nc)
{
	return devclone(c, nc);
}

int	 
hsvmewalk(Chan *c, char *name)
{
	if(c->qid != CHDIR)
		return 0;
	if(strcmp(name, "hsvme") == 0){
		c->qid = 1;
		return 1;
	}
	return 0;
}

void	 
hsvmestat(Chan *c, char *dp)
{
	print("hsvmestat\n");
	error(0, Egreg);
}

Chan*
hsvmeopen(Chan *c, int omode)
{
	c->mode = openmode(omode);
	c->flag |= COPEN;
	c->offset = 0;
	return c;
}

void	 
hsvmecreate(Chan *c, char *name, int omode, ulong perm)
{
	error(0, Eperm);
}

void	 
hsvmeclose(Chan *c)
{
}

long	 
hsvmeread(Chan *c, void *buf, long n)
{
	error(0, Egreg);
	return 0;
}

long	 
hsvmewrite(Chan *c, void *buf, long n)
{
	error(0, Egreg);
	return 0;
}

void	 
hsvmeremove(Chan *c)
{
	error(0, Eperm);
}

void	 
hsvmewstat(Chan *c, char *dp)
{
	error(0, Eperm);
}

void
hsvmeuserstr(Error *e, char *buf)
{
	consuserstr(e, buf);
}

void	 
hsvmeerrstr(Error *e, char *buf)
{
	rooterrstr(e, buf);
}

static void
hsvmeintr(int vec)
{
	ushort csr;
	struct hsvme *addr;

	print("hsvme intr\n");
	addr = HSVME;
	wbflush();
	csr = addr->csr;
	do {
		if (addr->csr & REF) {
			hsvmestats.rintr++;
			print("hsvme rintr\n");
		}
		if (addr->csr & XHF) {
			hsvmestats.tintr++;
			print("hsvme tintr\n");
		}
		if ((csr^XFF) & (XFF|EROFLOW|EFRAME|EPARITY|EXOFLOW)) {
			hsvmestats.parity++;
			hsvmerestart(addr);
			print("hsvme %ux: reset, csr = 0x%x\n",
				HSVME, csr);
		}
		wbflush();
	} while ((csr = addr->csr) & REF);
}
.
## diffname power/devhs.c 1990/0312
## diff -e /n/bootesdump/1990/0227/sys/src/9/mips/devhsvme.c /n/bootesdump/1990/0312/sys/src/9/mips/devhsvme.c
225,226c
		if(bp->rptr >= bp->wptr){
			if(bp->flags & S_DELIM){
				freeb(bp);
				break;
			}
			freeb(bp);
			bp = getq(q);
		}
	}

	/*
	 *  send the control byte if there is one
	 */
	if(ctl){
/*		print("->%.2uo\n", CTL|ctl); /**/
		addr->data = CTL|ctl;
	}

	/*
	 *  start the fifo emptying
	 */
/*	print("->%.2uo\n", TXEOD); /**/
	addr->data = TXEOD;

	qunlock(&hp->xmit);
}

/*
 *  return true if the input fifo is non-empty
 */
static int
notempty(void *arg)
{
	Device *addr;

	addr = (Device *)arg;
	return addr->csr & REF;
}

/*
 *  fill a block with what is currently buffered and send it upstream
 */
static void
upstream(Hsvme *hp, unsigned int ctl)
{
	int n;
	Block *bp;

	n = hp->wptr - hp->buf;
	bp = allocb(3 + n);
	bp->wptr[0] = hp->chan;
	bp->wptr[1] = hp->chan>>8;
	bp->wptr[2] = ctl;
	if(n)
		memcpy(&bp->wptr[3], hp->buf, n);
	bp->wptr += 3 + n;
	bp->flags |= S_DELIM;
	PUTNEXT(hp->rq, bp);
	hp->wptr = hp->buf;
}

/*
 *  Read bytes from the input fifo.  Since we take an interrupt every
 *  time the fifo goes non-empty, we need to waste time to let the
 *  fifo fill up.
 */
static void
hsvmekproc(void *arg)
{
	Hsvme *hp;
	Device *addr;
	unsigned int c;

	hp = (Hsvme *)arg;
	addr = hp->addr;
	hp->kstarted = 1;
	hp->wptr = hp->buf;

	for(;;){
		/*
		 *  die if the device is closed
		 */
		qlock(hp);
		if(hp->rq == 0){
			qunlock(hp);
			hp->kstarted = 0;
			wakeup(&hp->r);
			return;
		}

		/*
		 *  let the fifo fill a bit
		 */
		delay(1);

		/*
		 *  0xFFFF means an empty fifo
		 */
		while ((c = addr->data) != 0xFFFF) {
/*			print(" %.2uo<-\n", c); /**/
			if(c & CHNO){
				c &= 0x1FF;
				if(hp->chan == c)
					continue;
				/*
				 *  new channel, put anything saved upstream
				 */
				if(hp->wptr - hp->buf != 0)
					upstream(hp, 0);
				hp->chan = c;
			} else if(c & NND){
				/*
				 *  ctl byte, this ends a message
				 */
				upstream(hp, c);
			} else {
				/*
				 *  data byte, put in local buffer
				 */
				*hp->wptr++ = c;
				if(hp->wptr == &hp->buf[sizeof hp->buf])
					upstream(hp, 0);
			}
		}
		qunlock(hp);

		/*
		 *  sleep if input fifo empty
		 */
		if(!notempty(addr))
			sleep(&hp->kr, notempty, addr);
	}
}

/*
 *  only one flavor interrupt.   we have to use the less than half full
 *  and not empty bits to figure out whom to wake.
 */
static void
hsvmeintr(int vec)
{
	ushort csr;
	Device *addr;
	Hsvme *hp;

	hp = &hsvme[vec - Vmevec];
	if(hp < hsvme || hp > &hsvme[Nhsvme]){
		print("bad hsvme vec\n");
		return;
	}
	csr = hp->addr->csr;

	if (csr & REF) {
		hp->rintr++;
		wakeup(&hp->kr);
	}
	if (csr & XHF) {
		hp->tintr++;
		wakeup(&hp->r);
	}
	if ((csr^XFF) & (XFF|EROFLOW|EFRAME|EPARITY|EXOFLOW)) {
		hp->parity++;
		hsvmerestart(hp);
		print("hsvme %d: reset, csr = 0x%ux\n",
			HSVME, csr);
	}
.
219,223c
		n = bp->wptr - bp->rptr;
		if(n > burst)
			n = burst;
		burst -= n;
		while(n--){
/*			print("->%.2uo\n", *bp->rptr); /**/
			addr->data = *bp->rptr++;
.
215,217c
		freeb(bp);
	}
}

/*
 *  return true if the output fifo is at least half empty.
 *  the implication is that it can take at least another 1000 byte burst.
 */
static int
halfempty(void *arg)
{
	Device *addr;

	addr = (Device*)arg;
	return addr->csr & XHF;
}

/*
 *  output a block
 *
 *  the first 2 bytes of every message are the channel number,
 *  low order byte first.  the third is a possible trailing control
 *  character.
 */
void
hsvmeoput(Queue *q, Block *bp)
{
	Device *addr;
	Hsvme *hp;
	int burst;
	int chan;
	int ctl;
	int n;

	if(bp->type != M_DATA){
		freeb(bp);
		return;
	}

	/*
	 *  get a whole message before handing bytes to the device
	 */
	if(!putq(q, bp))
		return;

	/*
	 *  one transmitter at a time
	 */
	hp = (Hsvme *)q->ptr;
	qlock(&hp->xmit);
	addr = hp->addr;

	/*
	 *  parse message
	 */
	bp = getq(q);
	if(bp->wptr - bp->rptr < 3){
		freemsg(q, bp);
		qunlock(&hp->xmit);
		return;
	}
	chan = CHNO | *bp->rptr++ | (*bp->rptr++<<8);
	ctl = *bp->rptr++;

	/*
	 *  send the 8 bit data, burst are up to Maxburst (9-bit) bytes long
	 */
	if(!(addr->csr & XHF))
		sleep(&hp->r, halfempty, addr);
/*	print("->%.2uo\n", CHNO|chan);/**/
	addr->data = CHNO|chan;
	burst = Maxburst;
	while(bp){
		if(burst == 0){
			addr->data = TXEOD;
/*			print("->%.2uo\n", TXEOD); /**/
			if(!(addr->csr & XHF))
				sleep(&hp->r, halfempty, addr);
/*			print("->%.2uo\n", CHNO|chan); /**/
			addr->data = CHNO|chan;
			burst = Maxburst;
.
206,213c
	hp = &hsvme[s->dev];
	sprint(name, "**hsvme%d**", s->dev);
	q->ptr = q->other->ptr = hp;
	hp->rq = q;
	kproc(name, hsvmekproc, hp);
}

/*
 *  kill off the kernel process
 */
static int
kdead(void *arg)
{
	Hsvme *hp;

	hp = (Hsvme *)arg;
	return hp->kstarted == 0;
}
static void
hsvmestclose(Queue * q)
{
	Hsvme *hp;

	hp = (Hsvme *)q->ptr;
	qlock(hp);
	hp->rq = 0;
	qunlock(hp);
	wakeup(&hp->kr);
	sleep(&hp->r, kdead, hp);
}

/*
 *  free all blocks of a message in `q', `bp' is the first block
 *  of the message
 */
static void
freemsg(Queue *q, Block *bp)
{
	for(; bp; bp = getq(q)){
		if(bp->flags & S_DELIM){
			freeb(bp);
			return;
.
203,204c
	Hsvme *hp;
	char name[32];
.
201c
hsvmestopen(Queue *q, Stream *s)
.
199a
/*
 *	the stream routines
 */

/*
 *  create the kernel process for input
 */
.
172,173c
	return streamwrite(c, buf, n, 0);
.
165,166c
	return streamread(c, buf, n);
.
159a
	if(c->qid != CHDIR)
		streamclose(c);
.
144a
	if(c->qid == CHDIR){
		if(omode != OREAD)
			error(0, Eperm);
	}else
		streamopen(c, &hsvmeinfo);
.
138,139c
	devstat(c, dp, 0, 0, streamgen);
.
126,132c
	return devwalk(c, name, 0, 0, streamgen);
.
114c
	c = devattach('h', spec);
	c->dev = i;
	c->qid = CHDIR;
	return c;
.
110,112c
	i = strtoul(spec, 0, 0);
	if(i >= Nhsvme)
		error(0, Ebadarg);
	hp = &hsvme[i];
	hsvmerestart(hp);
	print("hsvme [%d] csr %ux\n", i, hp->addr->csr);
.
108c
	Hsvme *hp;
	int i;
	Chan *c;
.
100,104d
98c
 *  enable the device for interrupts, spec is the device number
.
84,89c
	delay(20);
.
81,82c
	for(i=0; i<Nhsvme; i++){
		hsvme[i].addr = HSVME+i;
		hsvme[i].vec = Vmevec+i;
		hsvme[i].addr->csr = RESET;
		setvmevec(hsvme[i].vec, hsvmeintr);
	}	
.
79c
	int i;
	Hsvme *hp;
.
75a
/*
 *  reset all vme boards
 */
.
73c
	delay(1);
.
70c
	delay(1);
.
67c
	addr->vector = hp->vec;
.
59c
	delay(20);
.
56a
	Device *addr;

	addr = hp->addr;

.
55c
hsvmerestart(Hsvme *hp)
.
53a
/*
 *  hsvme stream module definition
 */
static void hsvmeoput(Queue*, Block*);
static void hsvmestopen(Queue*, Stream*);
static void hsvmestclose(Queue*);
Qinfo hsvmeinfo = { nullput, hsvmeoput, hsvmestopen, hsvmestclose, "hsvme" };

/*
 *  restart a VME board
 */
.
52a
static void hsvmekproc(void*);
.
45,51d
22a
struct Hsvme {
	QLock;

	QLock	xmit;
	Device	*addr;
	int	vec;		/* interupt vector */
	Rendez	r;		/* output process */
	Rendez	kr;		/* input kernel process */
	int	chan;		/* current input channel */
	Queue	*rq;		/* read queue */
	uchar	buf[1024];	/* bytes being collected */
	uchar	*wptr;		/* pointer into buf */
	int	kstarted;	/* true if kernel process started */

	/* statistics */

	ulong	parity;		/* parity errors */
	ulong	rintr;		/* rcv interrupts */
	ulong	tintr;		/* transmit interrupts */
	ulong	in;		/* bytes in */
	ulong	out;		/* bytes out */
};

Hsvme hsvme[Nhsvme];

.
17,21c
/*
 *  hsvme datakit board
 */
struct Device {
	ushort	version;
	ushort	pad0x02;
	ushort	vector;
	ushort	pad0x06;
	ushort	csr;
	ushort	pad0x0A;
	ushort	data;
};
#define HSVME		VMEA24SUP(Device, 0xF90000)
.
14a
	Nhsvme=		1,
.
12c
	Maxburst=	1023,		/* maximum transmit burst size */
.
10a
typedef struct Hsvme	Hsvme;
typedef struct Device	Device;

.
## diffname power/devhs.c 1990/0315
## diff -e /n/bootesdump/1990/0312/sys/src/9/mips/devhsvme.c /n/bootesdump/1990/0315/sys/src/9/mips/devhsvme.c
367,368c
	chan = CHNO | bp->rptr[0] | (bp->rptr[1]<<8);
	ctl = bp->rptr[2];
	bp->rptr += 3;
.
## diffname power/devhs.c 1990/0403
## diff -e /n/bootesdump/1990/0315/sys/src/9/mips/devhsvme.c /n/bootesdump/1990/0403/sys/src/9/mips/devhsvme.c
519a
		}
.
496c
			miss = 0;
.
490,491c
		for(miss = 0; miss < 10; miss++){
.
488c
		 *  if we loop many times without finding a character, sleep
.
468a
	int miss;
.
161d
## diffname power/devhs.c 1990/0722
## diff -e /n/bootesdump/1990/0403/sys/src/9/mips/devhsvme.c /n/bootesdump/1990/0722/sys/src/9/mips/devhsvme.c
263c
	sprint(name, "hsvme%d", s->dev);
.
## diffname power/devhs.c 1990/0816
## diff -e /n/bootesdump/1990/0722/sys/src/9/mips/devhsvme.c /n/bootesdump/1990/0816/sys/src/9/mips/devhsvme.c
519d
488,491d
## diffname power/devhs.c 1990/0826
## diff -e /n/bootesdump/1990/0816/sys/src/9/mips/devhsvme.c /n/bootesdump/1990/0826/sys/src/9/mips/devhsvme.c
490a
			hp->in++;
.
## diffname power/devhs.c 1990/0930
## diff -e /n/bootesdump/1990/0826/sys/src/9/mips/devhsvme.c /n/bootesdump/1990/0930/sys/src/9/mips/devhsvme.c
557c
			vec - Vmevec, csr);
.
## diffname power/devhs.c 1990/1101
## diff -e /n/bootesdump/1990/0930/sys/src/9/mips/devhsvme.c /n/bootesdump/1990/1101/sys/src/9/mips/devhsvme.c
517a
		locked = 0;
.
479a
		locked = 1;
.
474a
	locked = 0;
	if(waserror()){
		if(locked)
			qunlock(hp);
		hp->kstarted = 0;
		wakeup(&hp->r);
		return;
	}

.
468a
	int locked;
.
## diffname power/devhs.c 1990/11151
## diff -e /n/bootesdump/1990/1101/sys/src/9/mips/devhsvme.c /n/bootesdump/1990/11151/sys/src/9/mips/devhsvme.c
91c
Qinfo hsvmeinfo =
{
	nullput,
	hsvmeoput,
	hsvmestopen,
	hsvmestclose,
	"hsvme"
};
.
## diffname power/devhs.c 1990/11211
## diff -e /n/bootesdump/1990/11151/sys/src/9/mips/devhsvme.c /n/bootesdump/1990/11211/sys/src/9/mips/devhsvme.c
241,253c
	error(Eperm);
.
235c
	error(Eperm);
.
216c
	if(c->qid.path != CHDIR)
.
210c
	error(Eperm);
.
198c
			error(Eperm);
.
196c
	if(c->qid.path == CHDIR){
.
171c
	c->qid.path = CHDIR;
.
165c
		error(Ebadarg);
.
## diffname power/devhs.c 1990/1214
## diff -e /n/bootesdump/1990/11211/sys/src/9/mips/devhsvme.c /n/bootesdump/1990/1214/sys/src/9/mips/devhsvme.c
522a
		USED(locked);
.
498d
489a
			poperror();
.
483a
		USED(locked);		/* so locked = 0 and locked = 1 stay */
.
463d
## diffname power/devhs.c 1991/0318
## diff -e /n/bootesdump/1991/0201/sys/src/9/mips/devhsvme.c /n/bootesdump/1991/0318/sys/src/9/power/devhsvme.c
445c
		memmove(&bp->wptr[3], hp->buf, n);
.
## diffname power/devhs.c 1991/0411
## diff -e /n/bootesdump/1991/0318/sys/src/9/power/devhsvme.c /n/bootesdump/1991/0411/sys/src/9/power/devhsvme.c
227c
hsvmewrite(Chan *c, void *buf, long n, ulong offset)
.
221c
hsvmeread(Chan *c, void *buf, long n, ulong offset)
.
## diffname power/devhs.c 1991/0419
## diff -e /n/bootesdump/1991/0411/sys/src/9/power/devhsvme.c /n/bootesdump/1991/0419/sys/src/9/power/devhsvme.c
186a
Chan*
hsvmeclwalk(Chan *c, char *name)
{
	return devclwalk(c, name);
}

.
## diffname power/devhs.c 1991/0427
## diff -e /n/bootesdump/1991/0419/sys/src/9/power/devhsvme.c /n/bootesdump/1991/0427/sys/src/9/power/devhsvme.c
187,192d
## diffname power/devhs.c 1991/0921
## diff -e /n/bootesdump/1991/0427/sys/src/9/power/devhsvme.c /n/bootesdump/1991/0921/sys/src/9/power/devhsvme.c
167c
	if(!hp->started)
		hsvmerestart(hp);
.
126a
	hp->started = 1;
.
47a
	int	started;
.
## diffname power/devhs.c 1991/1214
## diff -e /n/bootesdump/1991/0921/sys/src/9/power/devhsvme.c /n/bootesdump/1991/1214/sys/src/9/power/devhsvme.c
243a
	USED(c);
.
237a
	USED(c);
.
212a
	USED(c);
.
## diffname power/devhs.c 1992/0111
## diff -e /n/bootesdump/1991/1214/sys/src/9/power/devhsvme.c /n/bootesdump/1992/0111/sys/src/9/power/devhsvme.c
6c
#include	"../port/error.h"
.
## diffname power/devhs.c 1992/0117
## diff -e /n/bootesdump/1992/0111/sys/src/9/power/devhsvme.c /n/bootesdump/1992/0117/sys/src/9/power/devhsvme.c
421a
	poperror();
.
354a
	if(waserror()){
		qunlock(&hp->xmit);
		nexterror();
	}
.
## diffname power/devhs.c 1992/0123
## diff -e /n/bootesdump/1992/0117/sys/src/9/power/devhsvme.c /n/bootesdump/1992/0123/sys/src/9/power/devhsvme.c
541,542c
		if(!(addr->csr & REF)){
			if(hp->wptr == hp->buf)
				sleep(&hp->kr, notempty, addr);
			else
				tsleep(&hp->kr, notempty, addr, 100);
		}
.
539c
		 *  Sleep if input fifo empty. Make sure we don't hold onto
		 *  any byte for more tha 1/10 second.
.
533a
		if(hp->time && NOW >= hp->time)
			upstream(hp, 0);
.
528a
				if(hp->time == 0)
					hp->time = NOW + 100;
.
460a
	hp->time = 0;
.
46a
	ulong	time;		/* time byte in buf[0] arrived */
.
20a
#define NOW (MACHP(0)->ticks*MS2HZ)

.
## diffname power/devhs.c 1992/0321
## diff -e /n/bootesdump/1992/0123/sys/src/9/power/devhsvme.c /n/bootesdump/1992/0321/sys/src/9/power/devhsvme.c
2c
#include	"../port/lib.h"
.
## diffname power/devhs.c 1992/0612
## diff -e /n/bootesdump/1992/0612/sys/src/9/power/devhsvme.c /n/bootesdump/1992/0612/sys/src/9/power/devhs.c
587,589c
		hsrestart(hp);
		print("hs %d: reset, csr = 0x%ux\n",
			vec - Intvec, csr);
.
585c
	if((csr^XFF) & (XFF|EROFLOW|EFRAME|EPARITY|EXOFLOW)){
.
581c
	if(csr & XHF){
.
577c
	if(csr & REF){
.
570,572c
	hp = &hs[vec - Intvec];
	if(hp < hs || hp > &hs[Nhs]){
		print("bad hs vec\n");
.
567,568c
	HSdev *addr;
	Hs *hp;
.
564c
hsintr(int vec)
.
512c
		while((c = addr->data) != 0xFFFF){
.
480c
	hp = (Hs *)arg;
.
475,476c
	Hs *hp;
	HSdev *addr;
.
473c
hskproc(void *arg)
.
448c
upstream(Hs *hp, unsigned int ctl)
.
440c
	addr = (HSdev *)arg;
.
438c
	HSdev *addr;
.
371a
		poperror();
.
362d
357c
	hp = (Hs *)q->ptr;
	qlock(&hp->xmit);
.
336,337c
	HSdev *addr;
	Hs *hp;
.
334c
hsoput(Queue *q, Block *bp)
.
322c
	addr = (HSdev*)arg;
.
320c
	HSdev *addr;
.
293,294c
	while(waserror())
		;
	while(hp->kstarted){
		wakeup(&hp->kr);
		sleep(&hp->r, kdead, hp);
	}
	poperror();
.
289c
	hp = (Hs *)q->ptr;
.
287c
	Hs *hp;
.
285c
hsstclose(Queue * q)
.
281c
	hp = (Hs *)arg;
.
279c
	Hs *hp;
.
274c
 *  ask kproc to die and wait till it happens
.
270c
	kproc(name, hskproc, hp);
.
266,267c
	hp = &hs[s->dev];
	sprint(name, "hs%d", s->dev);
.
263c
	Hs *hp;
.
261c
hsstopen(Queue *q, Stream *s)
.
247c
hswstat(Chan *c, char *dp)
.
240c
hsremove(Chan *c)
.
234c
hswrite(Chan *c, void *buf, long n, ulong offset)
.
228c
hsread(Chan *c, void *buf, long n, ulong offset)
.
221c
hsclose(Chan *c)
.
214c
hscreate(Chan *c, char *name, int omode, ulong perm)
.
206c
		streamopen(c, &hsinfo);
.
200c
hsopen(Chan *c, int omode)
.
194c
hsstat(Chan *c, char *dp)
.
188c
hswalk(Chan *c, char *name)
.
182c
hsclone(Chan *c, Chan *nc)
.
173c
		hsrestart(hp);
.
171c
	hp = &hs[i];
.
169c
	if(i >= Nhs)
.
164c
	Hs *hp;
.
162c
hsattach(char *spec)
.
154c
hsinit(void)
.
143,147c
	for(i=0; i<Nhs; i++){
		hp = &hs[i];
		hp->addr = HSDEV+i;
		hp->vec = Intvec+i;
		hp->addr->csr = RESET;
		setvmevec(hp->vec, hsintr);
.
141c
	Hs *hp;
.
138c
hsreset(void)
.
120c
	 *  turn on device
.
110c
	HSdev *addr;
.
108c
hsrestart(Hs *hp)
.
104,106d
98,101c
	hsoput,
	hsstopen,
	hsstclose,
	"hs"
.
92,95c
static void hsoput(Queue*, Block*);
static void hsstopen(Queue*, Stream*);
static void hsstclose(Queue*);
Qinfo hsinfo =
.
90c
 *  hs stream module definition
.
76,88d
64,74c
static void hsintr(int);
static void hskproc(void*);
.
62c
Hs hs[Nhs];
.
41c
	HSdev	*addr;
.
37c
#define NOW (MACHP(0)->ticks*MS2HZ)
#define IPL(x)		((x)<<5)

struct Hs {
.
35d
23,33c
	/*
	 * csr reset flags
	 */
	FORCEW		= 0x0008,
	NORESET		= 0xFF00,
	RESET		= 0x0000,

	/*
	 * data flags
	 */
	CTL		= 0x0100,
	CHNO		= 0x0200,
	TXEOD		= 0x0400,
	NND		= 0x8000,
.
21c
	/*
	 * csr flags
	 */
	ALIVE		= 0x0001,
	IENABLE		= 0x0004,
	EXOFLOW		= 0x0008,
	IRQ		= 0x0010,
	EMUTE		= 0x0020,
	EPARITY		= 0x0040,
	EFRAME		= 0x0080,
	EROFLOW		= 0x0100,
	REF		= 0x0800,
	XFF		= 0x4000,
	XHF		= 0x8000,
.
18,19c
	Nhs=		1,
.
16c
	Intvec=		0xd0,		/* vme vector for interrupts */
.
11,12c
typedef struct Hs	Hs;
.
## diffname power/devhs.c 1992/0623
## diff -e /n/bootesdump/1992/0612/sys/src/9/power/devhs.c /n/bootesdump/1992/0623/sys/src/9/power/devhs.c
366,371d
343a
	if(BLEN(bp) < 3){
		bp = pullup(bp, 3);
		if(bp == 0){
			print("hsoput pullup failed\n");
			return;
		}
	}
.
## diffname power/devhs.c 1992/0703
## diff -e /n/bootesdump/1992/0623/sys/src/9/power/devhs.c /n/bootesdump/1992/0703/sys/src/9/power/devhs.c
551c
				tsleep(&hp->kr, notempty, addr, 2000);
.
547c
		 *  any byte for more than 1/10 second.
.
## diffname power/devhs.c 1992/0711
## diff -e /n/bootesdump/1992/0703/sys/src/9/power/devhs.c /n/bootesdump/1992/0711/sys/src/9/power/devhs.c
566d
241a
	USED(dp);
.
227a
	USED(offset);
.
221a
	USED(offset);
.
208a
	USED(name);
	USED(omode);
	USED(perm);
.
## diffname power/devhs.c 1993/0806 # deleted
## diff -e /n/bootesdump/1992/0711/sys/src/9/power/devhs.c /n/fornaxdump/1993/0806/sys/src/brazil/power/devhs.c
1,595d