## diffname gnot/devincon.c 1990/0312
## diff -e /dev/null /n/bootesdump/1990/0312/sys/src/9/68020/devincon.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"
typedef struct Incon Incon;
typedef struct Device Device;
#define NOW (MACHP(0)->ticks*MS2HZ)
#define DPRINT if(0)
enum {
Minstation= 2, /* lowest station # to poll */
Maxstation= 15, /* highest station # to poll */
Nincon= 1, /* number of incons */
Nraw= 1024, /* size of raw input buffer */
};
/*
* incon datakit board
*/
struct Device {
uchar cdata;
#define cpolln cdata
uchar u0;
uchar cstatus;
uchar u1;
uchar creset;
uchar u2;
uchar csend;
uchar u3;
ushort data_cntl; /* data is high byte, cntl is low byte */
uchar status;
#define cmd status
uchar u5;
uchar reset;
uchar u6;
uchar send;
uchar u7;
};
#define INCON ((Device *)0x40700000)
struct Incon {
QLock;
QLock xmit; /* transmit lock */
QLock reslock; /* reset lock */
Device *dev;
int station; /* station number */
int state; /* chip state */
Rendez r; /* output process */
Rendez kr; /* input kernel process */
ushort 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 */
ushort raw[Nraw];
ushort *rp;
ushort *wp;
/* statistics */
ulong overflow; /* overflow errors */
ulong pack0; /* channel 0 */
ulong crc; /* crc errors */
ulong in; /* bytes in */
ulong out; /* bytes out */
};
Incon incon[Nincon];
/*
* chip state
*/
enum {
Selecting,
Selected,
Dead,
};
/*
* internal chip registers
*/
#define sel_polln 0
#define sel_station 1
#define sel_poll0 2
#define sel_rcv_cnt 3
#define sel_rcv_tim 4
#define sel_tx_cnt 5
/*
* CSR bits
*/
#define INCON_RUN 0x80
#define INCON_STOP 0x00
#define ENABLE_IRQ 0x40
#define ENABLE_TX_IRQ 0x20
#define INCON_ALIVE 0x80
#define TX_FULL 0x10
#define TX_EMPTY 0x08
#define RCV_EMPTY 0x04
#define OVERFLOW 0x02
#define CRC_ERROR 0x01
/*
* polling constants
*/
#define HT_GNOT 0x30
#define ST_UNIX 0x04
#define NCHAN 16
static void inconkproc(void*);
/*
* incon stream module definition
*/
static void inconoput(Queue*, Block*);
static void inconstopen(Queue*, Stream*);
static void inconstclose(Queue*);
Qinfo inconinfo = { nullput, inconoput, inconstopen, inconstclose, "incon" };
/*
* set the incon parameters
*/
void
inconset(Incon *ip, int cnt, int delay)
{
Device *dev;
if (cnt<1 || cnt>14 || delay<1 || delay>15)
error(0, Ebadarg);
dev = ip->dev;
dev->cmd = sel_rcv_cnt | INCON_RUN;
*(uchar *)&dev->data_cntl = cnt;
dev->cmd = sel_rcv_tim | INCON_RUN;
*(uchar *)&dev->data_cntl = delay;
dev->cmd = INCON_RUN | ENABLE_IRQ;
}
static void
nop(void)
{
}
/*
* poll for a station number
*/
void
inconpoll(Incon *ip, int station)
{
ulong timer;
Device *dev;
dev = ip->dev;
/*
* get us to a known state
*/
ip->state = Dead;
dev->cmd = INCON_STOP;
/*
* try a station number
*/
dev->cmd = sel_station;
*(uchar *)&dev->data_cntl = station;
dev->cmd = sel_poll0;
*(uchar *)&dev->data_cntl = HT_GNOT;
dev->cmd = sel_rcv_cnt;
*(uchar *)&dev->data_cntl = 3;
dev->cmd = sel_rcv_tim;
*(uchar *)&dev->data_cntl = 15;
dev->cmd = sel_tx_cnt;
*(uchar *)&dev->data_cntl = 1;
dev->cmd = sel_polln;
*(uchar *)&dev->data_cntl = 0x00;
*(uchar *)&dev->data_cntl = ST_UNIX;
*(uchar *)&dev->data_cntl = NCHAN;
*(uchar *)&dev->data_cntl = 'g';
*(uchar *)&dev->data_cntl = 'n';
*(uchar *)&dev->data_cntl = 'o';
*(uchar *)&dev->data_cntl = 't';
dev->cpolln = 0;
/*
* poll and wait for ready (or 1/4 second)
*/
ip->state = Selecting;
dev->cmd = INCON_RUN | ENABLE_IRQ;
timer = NOW + 250;
while (NOW < timer) {
nop();
if(dev->status & INCON_ALIVE){
ip->station = station;
ip->state = Selected;
break;
}
}
}
/*
* reset the chip and find a new staion number
*/
void
inconrestart(Incon *ip)
{
Device *dev;
int i;
if(!canqlock(&ip->reslock))
return;
/*
* poll for incon station numbers
*/
for(i = Minstation; i <= Maxstation; i++){
inconpoll(ip, i);
if(ip->state == Selected)
break;
}
switch(ip->state) {
case Selecting:
print("incon[%d] not polled\n", ip-incon);
break;
case Selected:
print("incon[%d] station %d\n", ip-incon, ip->station);
inconset(ip, 8, 9);
break;
default:
print("incon[%d] bollixed\n", ip-incon);
break;
}
qunlock(&ip->reslock);
}
/*
* reset all incon chips.
*/
void
inconreset(void)
{
int i;
Incon *ip;
incon[0].dev = INCON;
incon[0].state = Selected;
incon[0].rp = incon[0].wp = incon[0].raw;
for(i=1; i<Nincon; i++){
incon[i].dev = INCON+i;
incon[i].state = Dead;
incon[i].dev->cmd = INCON_STOP;
incon[i].rp = incon[i].wp = incon[i].raw;
}
}
void
inconinit(void)
{
}
/*
* enable the device for interrupts, spec is the device number
*/
Chan*
inconattach(char *spec)
{
Incon *ip;
int i;
Chan *c;
i = strtoul(spec, 0, 0);
if(i >= Nincon)
error(0, Ebadarg);
ip = &incon[i];
if(ip->state != Selected)
inconrestart(ip);
c = devattach('i', spec);
c->dev = i;
c->qid = CHDIR;
return c;
}
Chan*
inconclone(Chan *c, Chan *nc)
{
return devclone(c, nc);
}
int
inconwalk(Chan *c, char *name)
{
return devwalk(c, name, 0, 0, streamgen);
}
void
inconstat(Chan *c, char *dp)
{
devstat(c, dp, 0, 0, streamgen);
}
Chan*
inconopen(Chan *c, int omode)
{
if(c->qid == CHDIR){
if(omode != OREAD)
error(0, Eperm);
}else
streamopen(c, &inconinfo);
c->mode = openmode(omode);
c->flag |= COPEN;
c->offset = 0;
return c;
}
void
inconcreate(Chan *c, char *name, int omode, ulong perm)
{
error(0, Eperm);
}
void
inconclose(Chan *c)
{
if(c->qid != CHDIR)
streamclose(c);
}
long
inconread(Chan *c, void *buf, long n)
{
return streamread(c, buf, n);
}
long
inconwrite(Chan *c, void *buf, long n)
{
return streamwrite(c, buf, n, 0);
}
void
inconremove(Chan *c)
{
error(0, Eperm);
}
void
inconwstat(Chan *c, char *dp)
{
error(0, Eperm);
}
void
inconuserstr(Error *e, char *buf)
{
consuserstr(e, buf);
}
void
inconerrstr(Error *e, char *buf)
{
rooterrstr(e, buf);
}
/*
* the stream routines
*/
/*
* create the kernel process for input
*/
static void
inconstopen(Queue *q, Stream *s)
{
Incon *ip;
char name[32];
ip = &incon[s->dev];
sprint(name, "**incon%d**", s->dev);
q->ptr = q->other->ptr = ip;
ip->rq = q;
kproc(name, inconkproc, ip);
}
/*
* kill off the kernel process
*/
static int
kDead(void *arg)
{
Incon *ip;
ip = (Incon *)arg;
return ip->kstarted == 0;
}
static void
inconstclose(Queue * q)
{
Incon *ip;
ip = (Incon *)q->ptr;
qlock(ip);
ip->rq = 0;
qunlock(ip);
wakeup(&ip->kr);
sleep(&ip->r, kDead, ip);
}
/*
* 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;
}
freeb(bp);
}
}
/*
* 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
inconoput(Queue *q, Block *bp)
{
Device *dev;
Incon *ip;
ulong end;
int chan;
int ctl;
int n, size;
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
*/
ip = (Incon *)q->ptr;
qlock(&ip->xmit);
dev = ip->dev;
/*
* parse message
*/
bp = getq(q);
if(bp->wptr - bp->rptr < 3){
freemsg(q, bp);
qunlock(&ip->xmit);
return;
}
chan = bp->rptr[0] | (bp->rptr[1]<<8);
ctl = bp->rptr[2];
bp->rptr += 3;
/*
* make sure there's an incon out there
*/
if(!(dev->status&INCON_ALIVE) || ip->state==Dead){
inconrestart(ip);
freemsg(q, bp);
qunlock(&ip->xmit);
return;
}
/*
* send the 8 bit data
*/
for(;;){
/*
* spin till there is room
*/
for(end = NOW+1000; dev->status & TX_FULL;){
nop(); /* make sure we don't optimize too much */
if(NOW > end){
print("incon output stuck\n");
freemsg(q, bp);
qunlock(&ip->xmit);
return;
}
}
/*
* put in next packet
*/
n = bp->wptr - bp->rptr;
if(n > 16)
n = 16;
size = n;
dev->cdata = chan;
DPRINT("CH|%uo->\n", chan);
while(n--){
DPRINT("->%uo\n", *bp->rptr);
*(uchar *)&dev->data_cntl = *bp->rptr++;
}
/*
* get next block
*/
if(bp->rptr >= bp->wptr){
if(bp->flags & S_DELIM){
freeb(bp);
break;
}
freeb(bp);
bp = getq(q);
if(bp==0)
break;
}
/*
* end packet
*/
dev->cdata = 0;
}
/*
* send the control byte if there is one
*/
if(ctl){
if(size >= 16){
dev->cdata = 0;
DPRINT("CH|%uo->\n", chan);
dev->cdata = chan;
}
DPRINT("CTL|%uo->\n", ctl);
dev->cdata = ctl;
}
dev->cdata = 0;
qunlock(&ip->xmit);
return;
}
/*
* return true if the raw fifo is non-empty
*/
static int
notempty(void *arg)
{
Incon *ip;
ip = (Incon *)arg;
return ip->wp!=ip->rp;
}
/*
* fill a block with what is currently buffered and send it upstream
*/
static void
upstream(Incon *ip, unsigned int ctl)
{
int n;
Block *bp;
n = ip->wptr - ip->buf;
bp = allocb(3 + n);
bp->wptr[0] = ip->chan;
bp->wptr[1] = ip->chan>>8;
bp->wptr[2] = ctl;
if(n)
memcpy(&bp->wptr[3], ip->buf, n);
bp->wptr += 3 + n;
bp->flags |= S_DELIM;
PUTNEXT(ip->rq, bp);
ip->wptr = ip->buf;
}
/*
* Read bytes from the raw input circular buffer.
*/
static void
inconkproc(void *arg)
{
Incon *ip;
unsigned int c;
uchar *lim;
ushort *p, *e;
ip = (Incon *)arg;
ip->kstarted = 1;
ip->wptr = ip->buf;
e = &ip->raw[Nraw];
for(;;){
/*
* die if the device is closed
*/
qlock(ip);
if(ip->rq == 0){
qunlock(ip);
ip->kstarted = 0;
wakeup(&ip->r);
return;
}
/*
* sleep if input fifo empty
*/
while(!notempty(ip))
sleep(&ip->kr, notempty, ip);
p = ip->rp;
/*
* get channel number
*/
c = (*p++)>>8;
if(p == e)
p = ip->raw;
DPRINT("<-CH|%uo\n", c);
if(ip->chan != c){
if(ip->wptr - ip->buf != 0)
upstream(ip, 0);
ip->chan = c;
}
/*
* null byte marks end of packet
*/
for(lim = &ip->buf[sizeof ip->buf];;){
if((c=*p++)&1) {
/*
* data byte, put in local buffer
*/
c = *ip->wptr++ = c>>8;
DPRINT("<-%uo\n", c);
if(ip->wptr >= lim)
upstream(ip, 0);
} else if (c>>=8) {
/*
* control byte ends block
*/
DPRINT("<-CTL|%uo\n", c);
upstream(ip, c);
} else {
/* end of packet */
break;
}
if(p == e)
p = ip->raw;
}
ip->rp = p;
qunlock(ip);
}
}
/*
* read the packets from the device into the raw input buffer.
* we have to do this at interrupt tevel to turn off the interrupts.
*/
static
rdpackets(Incon *ip)
{
Device *dev;
unsigned int c;
ushort *p, *e;
int n;
dev = ip->dev;
while(!(dev->status & RCV_EMPTY)){
n = ip->rp - ip->wp;
if(n <= 0)
n += Nraw;
if(n < 19){
/*
* no room in the raw queue, throw it away
*/
c = (dev->data_cntl)>>8;
for(c=0;c<18;c++){
if(dev->data_cntl == 0)
break;
}
} else {
/*
* put packet in the raw queue
*/
p = ip->wp;
e = &ip->raw[Nraw];
*p++ = dev->data_cntl;
if(p == e)
p = ip->raw;
do {
*p++ = c = dev->data_cntl;
if(p == e)
p = ip->raw;
} while(c);
ip->wp = p;
}
}
wakeup(&ip->kr);
}
/*
* Receive an incon interrupt. One entry point
* for all types of interrupt. Until we figure out
* how to use more than one incon, this routine only
* is for incon[0].
*/
inconintr(Ureg *ur)
{
uchar status;
Incon *ip;
ip = &incon[0];
status = ip->dev->status;
if(!(status & RCV_EMPTY))
rdpackets(ip);
/* check for exceptional conditions */
if(status&(OVERFLOW|CRC_ERROR)){
if(status&OVERFLOW){
print("incon overflow\n");
ip->overflow++;
}
if(status&CRC_ERROR){
print("incon crc error\n");
ip->crc++;
}
}
/* see if it died underneath us */
if(!(status&INCON_ALIVE)){
switch(ip->state){
case Selected:
ip->dev->cmd = INCON_STOP;
print("Incon died\n");
break;
case Selecting:
print("rejected\n");
break;
default:
ip->dev->cmd = INCON_STOP;
break;
}
ip->state = Dead;
}
}
.
## diffname gnot/devincon.c 1990/0315
## diff -e /n/bootesdump/1990/0312/sys/src/9/68020/devincon.c /n/bootesdump/1990/0315/sys/src/9/68020/devincon.c
665,713d
660c
bp = nextin(ip, c);
if(bp == 0)
continue;
.
653,654c
if(bp->wptr >= bp->lim){
bp = nextin(ip, 0);
if(bp == 0)
continue;
}
.
651c
c = *bp->wptr++ = c>>8;
.
646,647c
for(;;){
if((c=dev->data_cntl)&1) {
.
638,639c
if(bp->wptr - bp->rptr > 3){
bp = nextin(ip, 0);
if(bp == 0)
continue;
}
.
633,635c
c = (dev->data_cntl)>>8;
.
629a
/*
* drop an input packet on the floor
*/
static void
droppacket(Device *dev)
{
int i;
int c;
for(i = 0; i < 17; i++){
c = dev->data_cntl;
if(c==0)
break;
}
}
/*
* advance the queue. if we've run out of staged input blocks,
* drop the packet and return 0. otherwise return the next input
* block to fill.
*/
static Block *
nextin(Incon *ip, unsigned int c)
{
Block *bp = ip->inb[ip->wi];
bp->base[0] = ip->chan;
bp->base[1] = ip->chan>>8;
bp->base[2] = c;
ip->wi = (ip->wi + 1) % Nin;
if(((ip->wi+1)%Nin) == ip->ri){
droppacket(ip->dev);
return 0;
}
return ip->inb[ip->wi];
}
/*
* read the packets from the device into the staged input blocks.
* we have to do this at interrupt tevel to turn off the interrupts.
*/
static void
rdpackets(Incon *ip)
{
Block *bp;
unsigned int c;
Device *dev;
dev = ip->dev;
while(!(dev->status & RCV_EMPTY)){
bp = ip->inb[ip->wi];
if(((ip->wi+1)%Nin) == ip->ri || bp==0){
c = dev->data_cntl;
droppacket(dev);
continue;
}
.
626,628c
while(ip->ri != ip->wi){
PUTNEXT(ip->rq, ip->inb[ip->ri]);
bp = ip->inb[ip->ri] = allocb(128);
bp->wptr += 3;
ip->ri = (ip->ri+1)%Nin;
}
qunlock(ip);
}
}
.
624c
* send blocks upstream and stage new blocks
.
612a
* sleep if input fifo empty
*/
sleep(&ip->kr, notempty, ip);
/*
.
610c
/*
* create a number of blocks for input
*/
for(i = 0; i < Nin; i++){
bp = ip->inb[i] = allocb(128);
bp->wptr += 3;
}
.
608d
602,604c
Block *bp;
int i;
.
574,595d
570c
return ip->ri!=ip->wi;
.
553a
MICROSECOND;
.
261c
incon[i].ri = incon[i].wi = 0;
.
256c
incon[0].ri = incon[0].wi = 0;
inconset(&incon[0], 8, 9);
.
145c
MICROSECOND;
*(uchar *)&dev->data_cntl = del;
MICROSECOND;
.
143a
MICROSECOND;
.
142a
MICROSECOND;
.
138c
if (cnt<1 || cnt>14 || del<1 || del>15)
.
134c
inconset(Incon *ip, int cnt, int del)
.
68a
Block *inb[Nin];
ushort wi;
ushort ri;
.
65,67c
/* input blocks */
.
61,62d
22c
Nin= 32, /* size of raw input buffer */
.
15a
static int SpEcIaL;
#define MICROSECOND SpEcIaL = 0
.
## diffname gnot/devincon.c 1990/0320
## diff -e /n/bootesdump/1990/0315/sys/src/9/68020/devincon.c /n/bootesdump/1990/0320/sys/src/9/68020/devincon.c
761c
screenputc('+');
.
757c
screenputc('^');
.
733,734c
/*
* pass a block on if it doesn't have room for one more
* packet. this way we don't have to check per byte.
*/
if(p + 16 > bp->lim){
bp->wptr = p;
bp = nextin(ip, 0);
if(bp == 0)
goto done;
p = bp->wptr;
}
}
bp->wptr = p;
done:
if(first != ip->wi)/**/
wakeup(&ip->kr);
.
727c
goto done;
p = bp->wptr;
.
724c
bp->wptr = p;
.
713,719c
*p++ = c>>8;
.
700c
goto done;
p = bp->wptr;
.
697c
if(p - bp->rptr > 3){
bp->wptr = p;
.
695d
684,690d
682a
bp = ip->inb[ip->wi];
if(bp==0){
droppacket(ip->dev);
goto done;
}
p = bp->wptr;
.
680a
uchar *p;
int first = ip->wi;
.
664,667d
662c
ip->wi = next;
.
658a
next = (ip->wi+1)%Nin;
if(next == ip->ri){
bp->wptr = bp->base+3;
droppacket(ip->dev);
return 0;
}
.
657a
int next;
.
642,645c
screenputc('!');
while(!(dev->status & RCV_EMPTY)){
for(i = 0; i < 17; i++){
c = dev->data_cntl;
if(c==0)
break;
}
.
625c
bp = ip->inb[ip->ri] = allocb(Bsize);
.
599c
bp = ip->inb[i] = allocb(Bsize);
.
563a
MICROSECOND;
.
562d
560d
558a
MICROSECOND;
.
557c
MICROSECOND;
.
527d
525d
25c
Nin= 16, /* Blocks in the input ring */
Bsize= 128, /* size of an input ring block */
.
9a
#include "ureg.h"
.
## diffname gnot/devincon.c 1990/0321
## diff -e /n/bootesdump/1990/0320/sys/src/9/68020/devincon.c /n/bootesdump/1990/0321/sys/src/9/68020/devincon.c
751d
744,745d
728,729d
706,707d
701a
if(c == 0){
droppacket(dev);
continue;
}
.
693,694c
flushfifo(ip->dev);
return;
.
673a
next = (ip->wi+3)%Nin;
if(next == ip->ri){
bp->wptr = bp->base+3;
return bp;
}
ip->wi = (ip->wi+1)%Nin;
.
672d
663,668c
bp = ip->inb[ip->wi];
.
660c
Block *bp;
.
652a
* flush the input fifo
*/
static void
flushfifo(Device *dev)
{
while(!(dev->status & RCV_EMPTY))
droppacket(dev);
}
/*
.
642,648c
for(i = 0; i < 17; i++){
c = dev->data_cntl;
if(c==0)
break;
.
634c
* drop a single packet
.
27a
Mfifo= 0xff /* a mask, must be 2^n-1, must be > Nin */
.
26c
Nin= 64, /* Blocks in the input ring */
.
## diffname gnot/devincon.c 1990/0322
## diff -e /n/bootesdump/1990/0321/sys/src/9/68020/devincon.c /n/bootesdump/1990/0322/sys/src/9/68020/devincon.c
625c
bp = ip->inb[ip->ri];
n = BLEN(bp);
if(n <= 64){
nbp = allocb(n);
memcpy(nbp->wptr, bp->rptr, n);
nbp->wptr += n;
freeb(bp);
PUTNEXT(ip->rq, nbp);
} else {
PUTNEXT(ip->rq, bp);
}
.
622c
* send blocks upstream and stage new blocks. if the block is small
* (< 64 bytes) copy into a smaller buffer.
.
590,591c
Block *bp, *nbp;
int i, n;
.
26c
Nin= 32, /* Blocks in the input ring */
.
## diffname gnot/devincon.c 1990/0330
## diff -e /n/bootesdump/1990/0322/sys/src/9/68020/devincon.c /n/bootesdump/1990/0330/sys/src/9/68020/devincon.c
267c
/* inconset(&incon[0], 8, 9); /**/
.
## diffname gnot/devincon.c 1990/0331
## diff -e /n/bootesdump/1990/0330/sys/src/9/68020/devincon.c /n/bootesdump/1990/0331/sys/src/9/68020/devincon.c
628,636c
PUTNEXT(ip->rq, bp);
.
267c
/* inconset(&incon[0], 3, 15); /**/
.
246c
inconset(ip, 3, 15);
.
## diffname gnot/devincon.c 1990/05312
## diff -e /n/bootesdump/1990/0331/sys/src/9/68020/devincon.c /n/bootesdump/1990/05312/sys/src/9/68020/devincon.c
759a
if(bp->wptr != bp->base+3)
nextin(ip, 0);
.
## diffname gnot/devincon.c 1990/0619
## diff -e /n/bootesdump/1990/05312/sys/src/9/68020/devincon.c /n/bootesdump/1990/0619/sys/src/9/68020/devincon.c
793d
789,791c
if(status&CRC_ERROR)
.
786,787c
if(status&OVERFLOW)
.
## diffname gnot/devincon.c 1990/0623
## diff -e /n/bootesdump/1990/0619/sys/src/9/68020/devincon.c /n/bootesdump/1990/0623/sys/src/9/68020/devincon.c
231a
print("inconrestart\n");
.
## diffname gnot/devincon.c 1990/0629
## diff -e /n/bootesdump/1990/0623/sys/src/9/68020/devincon.c /n/bootesdump/1990/0629/sys/src/9/68020/devincon.c
809a
}
incontoggle()
{
incondebug ^= 1;
.
679a
if(incondebug)
print("<-(%d)%uo %d\n", ip->chan, c, bp->wptr-bp->rptr)-3;
.
494a
if(incondebug)
print("->(%d)%uo %d\n", chan, ctl, bp->wptr - bp->rptr);
.
135a
int incondebug;
.
## diffname gnot/devincon.c 1990/0725
## diff -e /n/bootesdump/1990/0629/sys/src/9/68020/devincon.c /n/bootesdump/1990/0725/sys/src/9/68020/devincon.c
815c
ip->state = Notliving;
.
503c
if(!(dev->status&INCON_ALIVE) || ip->state==Notliving){
.
430c
sleep(&ip->r, kNotliving, ip);
.
413c
kNotliving(void *arg)
.
403c
sprint(name, "incon%d", s->dev);
.
274c
incon[i].state = Notliving;
.
180c
ip->state = Notliving;
.
92c
Notliving,
.
## diffname gnot/devincon.c 1990/0731
## diff -e /n/bootesdump/1990/0725/sys/src/9/68020/devincon.c /n/bootesdump/1990/0731/sys/src/9/68020/devincon.c
693c
ip->wi = next;
.
688c
next = (ip->wi+1)%Nin;
.
686c
print("<-(%d)%uo %d\n", ip->chan, c, bp->wptr-bp->rptr);
.
## diffname gnot/devincon.c 1990/0802
## diff -e /n/bootesdump/1990/0731/sys/src/9/68020/devincon.c /n/bootesdump/1990/0802/sys/src/9/68020/devincon.c
495a
if(chan<=0)
print("bad channel %d\n", chan);
.
## diffname gnot/devincon.c 1990/1024
## diff -e /n/bootesdump/1990/0802/sys/src/9/68020/devincon.c /n/bootesdump/1990/1024/sys/src/9/68020/devincon.c
612a
/*
* ignore errors
*/
if(waserror())
;
.
## diffname gnot/devincon.c 1990/1101
## diff -e /n/bootesdump/1990/1024/sys/src/9/68020/devincon.c /n/bootesdump/1990/1101/sys/src/9/68020/devincon.c
648a
locked = 0;
.
627a
locked = 1;
.
613,617c
locked = 0;
if(waserror()){
if(locked)
qunlock(ip);
ip->kstarted = 0;
wakeup(&ip->r);
return;
}
.
600a
int locked;
.
480d
467c
if(streamparse("inconset", bp))
inconsetctl(ip, bp);
else
freeb(bp);
.
465a
ip = (Incon *)q->ptr;
.
160a
/*
* parse a set request
*/
void
inconsetctl(Incon *ip, Block *bp)
{
char *field[3];
int n;
int del;
int cnt;
del = 15;
n = getfields((char *)bp->rptr, field, 3, ' ');
switch(n){
default:
freeb(bp);
error(0, Ebadarg);
case 2:
del = strtol(field[1], 0, 0);
if(del<0 || del>15){
freeb(bp);
error(0, Ebadarg);
}
/* fall through */
case 1:
cnt = strtol(field[0], 0, 0);
if(cnt<0 || cnt>15){
freeb(bp);
error(0, Ebadarg);
}
}
inconset(ip, cnt, del);
freeb(bp);
}
.
## diffname gnot/devincon.c 1990/11151
## diff -e /n/bootesdump/1990/1101/sys/src/9/68020/devincon.c /n/bootesdump/1990/11151/sys/src/9/68020/devincon.c
134c
Qinfo inconinfo =
{
nullput,
inconoput,
inconstopen,
inconstclose,
"incon"
};
.
## diffname gnot/devincon.c 1990/11211
## diff -e /n/bootesdump/1990/11151/sys/src/9/68020/devincon.c /n/bootesdump/1990/11211/sys/src/9/68020/devincon.c
416,428c
error(Eperm);
.
410c
error(Eperm);
.
391c
if(c->qid.path != CHDIR)
.
385c
error(Eperm);
.
373c
error(Eperm);
.
371c
if(c->qid.path == CHDIR){
.
346c
c->qid.path = CHDIR;
c->qid.vers = 0;
.
339c
error(Ebadarg);
.
196c
error(Ebadarg);
.
189c
error(Ebadarg);
.
184c
error(Ebadarg);
.
154c
error(Ebadarg);
.
## diffname gnot/devincon.c 1990/1212
## diff -e /n/bootesdump/1990/11211/sys/src/9/68020/devincon.c /n/bootesdump/1990/1212/sys/src/9/68020/devincon.c
605a
if(dev->status & TX_FULL)
print("inconfull\n");
.
602a
for(end = NOW+1000; dev->status & TX_FULL;){
nop(); /* make sure we don't optimize too much */
if(NOW > end){
print("incon output stuck\n");
freemsg(q, bp);
qunlock(&ip->xmit);
return;
}
}
.
## diffname gnot/devincon.c 1990/1214
## diff -e /n/bootesdump/1990/1212/sys/src/9/68020/devincon.c /n/bootesdump/1990/1214/sys/src/9/68020/devincon.c
698a
USED(locked);
.
693d
683a
poperror();
.
679a
locked = 1;
.
678c
USED(locked);
.
646c
int i;
.
17,18c
#define MICROSECOND USED(NOW)
.
## diffname gnot/devincon.c 1991/0115
## diff -e /n/bootesdump/1990/1214/sys/src/9/68020/devincon.c /n/bootesdump/1991/0115/sys/src/9/68020/devincon.c
880c
void
incontoggle(void)
.
## diffname gnot/devincon.c 1991/0411
## diff -e /n/bootesdump/1991/0201/sys/src/9/68020/devincon.c /n/bootesdump/1991/0411/sys/src/9/gnot/devincon.c
402c
inconwrite(Chan *c, void *buf, long n, ulong offset)
.
396c
inconread(Chan *c, void *buf, long n, ulong offset)
.
## diffname gnot/devincon.c 1991/0419
## diff -e /n/bootesdump/1991/0411/sys/src/9/gnot/devincon.c /n/bootesdump/1991/0419/sys/src/9/gnot/devincon.c
361a
Chan*
inconclwalk(Chan *c, char *name)
{
return devclwalk(c, name);
}
.
## diffname gnot/devincon.c 1991/0427
## diff -e /n/bootesdump/1991/0419/sys/src/9/gnot/devincon.c /n/bootesdump/1991/0427/sys/src/9/gnot/devincon.c
362,367d
## diffname gnot/devincon.c 1991/0906
## diff -e /n/bootesdump/1991/0427/sys/src/9/gnot/devincon.c /n/bootesdump/1991/0906/sys/src/9/gnot/devincon.c
275,276d
## diffname gnot/devincon.c 1991/1122
## diff -e /n/bootesdump/1991/0906/sys/src/9/gnot/devincon.c /n/bootesdump/1991/1122/sys/src/9/gnot/devincon.c
691a
ip->in += BLEN(bp);
.
568a
ip->out += n;
.
559a
ip->wait = (n + ip->wait)>>1;
.
551c
start = NOW;
for(n = 0, end = start+1000; dev->status & TX_FULL; n++){
.
489c
ulong start, end;
.
396c
char b[256];
Incon *i;
if(c->qid.path == CHDIR)
return devdirread(c, buf, n, incondir, 1, streamgen);
else if(c->qid.path == Qstats){
i = &incon[c->dev];
sprint(b, "in: %d\nout: %d\noverflow: %d\ncrc: %d\nwait: %d\n", i->in,
i->out, i->overflow, i->crc, i->wait);
return stringread(buf, n, b, offset);
} else
return streamread(c, buf, n);
.
369c
if(c->qid.path == CHDIR || c->qid.path == Qstats){
.
363c
devstat(c, dp, incondir, 1, streamgen);
.
357c
return devwalk(c, name, incondir, 1, streamgen);
.
143a
Dirtab incondir[]={
"stats", {Qstats}, 0, 0444,
};
.
80a
ulong wait; /* wait time in milliseconds */
.
27c
Mfifo= 0xff, /* a mask, must be 2^n-1, must be > Nin */
Qstats= 1, /* qid of the statistics file */
.
## diffname gnot/devincon.c 1991/1209
## diff -e /n/bootesdump/1991/1122/sys/src/9/gnot/devincon.c /n/bootesdump/1991/1209/sys/src/9/gnot/devincon.c
831a
if(bp==0){
flushfifo(ip->dev);
return;
}
.
811a
if(bp==0){
flushfifo(ip->dev);
return;
}
.
## diffname gnot/devincon.c 1991/1219
## diff -e /n/bootesdump/1991/1209/sys/src/9/gnot/devincon.c /n/bootesdump/1991/1219/sys/src/9/gnot/devincon.c
458,465d
450a
wakeup(&ip->kr);
sleep(&ip->r, kNotliving, ip);
.
440a
* first wait for any old ones to die
.
439a
* for sleeping while kproc dies
*/
static int
kNotliving(void *arg)
{
Incon *ip;
ip = (Incon *)arg;
return ip->kstarted == 0;
}
/*
.
## diffname gnot/devincon.c 1992/0111
## diff -e /n/bootesdump/1991/1219/sys/src/9/gnot/devincon.c /n/bootesdump/1992/0111/sys/src/9/gnot/devincon.c
6c
#include "../port/error.h"
.
## diffname gnot/devincon.c 1992/0321
## diff -e /n/bootesdump/1992/0111/sys/src/9/gnot/devincon.c /n/bootesdump/1992/0321/sys/src/9/gnot/devincon.c
2c
#include "../port/lib.h"
.
## diffname gnot/devincon.c 1992/0611
## diff -e /n/bootesdump/1992/0321/sys/src/9/gnot/devincon.c /n/bootesdump/1992/0611/sys/src/9/gnot/devincon.c
877a
void
.
## diffname gnot/devincon.c 1992/0623
## diff -e /n/bootesdump/1992/0611/sys/src/9/gnot/devincon.c /n/bootesdump/1992/0623/sys/src/9/gnot/devincon.c
865c
if(bp->wptr != bp->rptr+3)
.
778c
bp->wptr = bp->rptr+3;
.
770,772c
bp->rptr[0] = ip->chan;
bp->rptr[1] = ip->chan>>8;
bp->rptr[2] = c;
.
545,549d
527a
if(BLEN(bp) < 3){
bp = pullup(bp, 3);
if(bp == 0){
print("inconoput pullup failed\n");
return;
}
}
.
412c
return readstr(offset, buf, n, b);
.
## diffname gnot/devincon.c 1992/0711
## diff -e /n/bootesdump/1992/0623/sys/src/9/gnot/devincon.c /n/bootesdump/1992/0711/sys/src/9/gnot/devincon.c
885a
USED(ur);
.
672c
Block *bp;
.
431a
USED(c, dp);
.
425a
USED(c);
.
419a
USED(offset);
.
389a
USED(c, name, omode, perm);
.
312d
276d
## diffname gnot/devincon.c 1993/0501 # deleted
## diff -e /n/bootesdump/1992/0711/sys/src/9/gnot/devincon.c /n/fornaxdump/1993/0501/sys/src/brazil/gnot/devincon.c
1,925d
|
