static void
etherreadproc(void *a)
{
int i, n, nwants;
Buf *bp, *dbp;
Ether *e = a;
threadsetname("etherread");
while(e->exiting == 0){
bp = nbrecvp(e->rc);
if(bp == nil){
bp = allocbuf(e); /* leak() may think we leak */
if(e->bread(e, bp) < 0){
freebuf(e, bp);
break;
}
if(bp->ndata == 0){
/* may be a short packet; continue */
if(0)dprint(2, "%s: read: short\n", argv0);
freebuf(e, bp);
continue;
}else
setbuftype(bp);
}
e->nin++;
nwants = 0;
for(i = 0; i < e->nconns; i++)
nwants += cwantsbp(e->conns[i], bp);
for(i = 0; nwants > 0 && i < e->nconns; i++)
if(cwantsbp(e->conns[i], bp)){
n = bp->ndata;
if(e->conns[i]->type == -2 && n > 64)
n = 64;
if(nwants-- == 1){
bp->ndata = n;
dbp = bp;
bp = nil;
}else{
dbp = allocbuf(e);
memmove(dbp->rp, bp->rp, n);
dbp->ndata = n;
dbp->type = bp->type;
}
if(nbsendp(e->conns[i]->rc, dbp) == 0){
deprint(2, "%s: (in) packet lost\n", argv0);
e->nierrs++;
freebuf(e, dbp);
}
}
freebuf(e, bp);
}
deprint(2, "%s: writeproc exiting\n", argv0);
etherexiting(e);
closedev(e->dev);
usbfsdel(&e->fs);
}
static void
statusreader(void *u)
{
Areader *a;
Channel *c;
Packser *pk;
Serialport *p;
Serial *ser;
int cl;
p = u;
ser = p->s;
threadsetname("statusreader thread");
/* big buffering, fewer bytes lost */
c = chancreate(sizeof(Packser *), 128);
a = emallocz(sizeof(Areader), 1);
a->p = p;
a->c = c;
incref(ser->dev);
proccreate(epreader, a, 16*1024);
while((pk = recvp(c)) != nil){
memmove(p->data, pk->b, pk->nb);
p->ndata = pk->nb;
free(pk);
dsprint(2, "serial %p: status reader %d \n", p, p->ndata);
/* consume it all */
while(p->ndata != 0){
dsprint(2, "serial %p: status reader to consume: %d\n",
p, p->ndata);
cl = recvul(p->w4data);
if(cl < 0)
break;
cl = sendul(p->gotdata, 1);
if(cl < 0)
break;
}
}
shutdownchan(c);
devctl(ser->dev, "detach");
closedev(ser->dev);
usbfsdel(&p->fs);
}
static void
fsend(Usbfs*_1)
{
dprint(2, "%s: fsend\n", argv0);
usbfsdel(nil);
}
static void
epreader(void *u)
{
int dfd, rcount, cl, ntries, recov;
char err[40];
Areader *a;
Channel *c;
Packser *pk;
Serial *ser;
Serialport *p;
threadsetname("epreader proc");
a = u;
p = a->p;
ser = p->s;
c = a->c;
free(a);
qlock(ser); /* this makes the reader wait end of initialization too */
dfd = p->epin->dfd;
qunlock(ser);
ntries = 0;
pk = nil;
do {
if (pk == nil)
pk = emallocz(sizeof(Packser), 1);
Eagain:
rcount = read(dfd, pk->b, sizeof pk->b);
if(serialdebug > 5)
dsprint(2, "%d %#ux%#ux ", rcount, p->data[0],
p->data[1]);
if(rcount < 0){
if(ntries++ > 100)
break;
qlock(ser);
recov = serialrecover(ser, p, nil, "epreader: bulkin error");
qunlock(ser);
if(recov >= 0)
goto Eagain;
}
if(rcount == 0)
continue;
if(rcount >= ser->inhdrsz){
rcount = cpdata(ser, p, pk->b, pk->b, rcount);
if(rcount != 0){
pk->nb = rcount;
cl = sendp(c, pk);
if(cl < 0){
/*
* if it was a time-out, I don't want
* to give back an error.
*/
rcount = 0;
break;
}
}else
free(pk);
qlock(ser);
ser->recover = 0;
qunlock(ser);
ntries = 0;
pk = nil;
}
} while(rcount >= 0 || (rcount < 0 && strstr(err, "timed out") != nil));
if(rcount < 0)
fprint(2, "%s: error reading %s: %r\n", argv0, p->fs.name);
free(pk);
nbsendp(c, nil);
if(p->w4data != nil)
chanclose(p->w4data);
if(p->gotdata != nil)
chanclose(p->gotdata);
devctl(ser->dev, "detach");
closedev(ser->dev);
usbfsdel(&p->fs);
}
