Browse Source

Removed plan9 extensions from libusb

Signed-off-by: Keith Poole <keith.poole@gmail.com>
Keith Poole 8 years ago
parent
commit
101fc50b0a

+ 3 - 3
sys/include/usb/ether.h

@@ -49,7 +49,7 @@ struct Buf
 
 struct Conn
 {
-	Ref;			/* one per file in use */
+	Ref	Ref;			/* one per file in use */
 	int	nb;
 	int	type;
 	int	headersonly;
@@ -74,7 +74,7 @@ struct Etherops
 
 struct Ether
 {
-	QLock;
+	QLock	QLock;
 	QLock	wlck;			/* write one at a time */
 	int	epinid;			/* epin address */
 	int	epoutid;			/* epout address */
@@ -101,7 +101,7 @@ struct Ether
 	Channel*rc;			/* read channel (of Buf*) */
 	Channel*wc;			/* write channel (of Buf*) */
 	Channel*bc;			/* free buf. chan. (of Buf*) */
-	Etherops;
+	Etherops	Etherops;
 	Usbfs	fs;
 };
 

+ 2 - 2
sys/include/usb/serial.h

@@ -79,12 +79,12 @@ struct Serialport {
 };
 
 struct Serial {
-	QLock;
+	QLock	QLock;
 	Dev	*dev;		/* usb device*/
 
 	int	type;		/* serial model subtype */
 	int	recover;	/* # of non-fatal recovery tries */
-	Serialops;
+	Serialops	Serialops;
 
 	int	hasepintr;
 

+ 2 - 2
sys/include/usb/ums.h

@@ -59,7 +59,7 @@ enum
  */
 struct Umsc
 {
-	ScsiReq;
+	ScsiReq	ScsiReq;
 	uint64_t	blocks;
 	int64_t	capacity;
 
@@ -78,7 +78,7 @@ struct Umsc
 
 struct Ums
 {
-	QLock;
+	QLock	QLock;
 	Dev	*dev;
 	Dev	*epin;
 	Dev	*epout;

+ 1 - 1
sys/include/usb/usb.h

@@ -173,7 +173,7 @@ enum {
  */
 struct Dev
 {
-	Ref;
+	Ref	Ref;
 	char*	dir;		/* path for the endpoint dir */
 	int	id;		/* usb id for device or ep. number */
 	int	dfd;		/* descriptor for the data file */

+ 13 - 13
sys/src/libusb/audio/audiofs.c

@@ -46,7 +46,7 @@ enum {
 
 struct Fid
 {
-	QLock;
+	QLock	QLock;
 	int	fid;
 	Dir	*dir;
 	uint16_t	flags;
@@ -387,10 +387,10 @@ ropen(Fid *f)
 
 	if(thdr.mode != OREAD && (f->dir->mode & 0x2) == 0)
 		return Eperm;
-	qlock(f);
+	qlock(&f->QLock);
 	if(f->dir == &dirs[Qaudioctl] && f->fiddata == nil)
 		f->fiddata = allocaudioctldata();
-	qunlock(f);
+	qunlock(&f->QLock);
 	rhdr.iounit = 0;
 	rhdr.qid = f->dir->qid;
 	f->flags |= Open;
@@ -497,9 +497,9 @@ readproc(void *x)
 		assert(a->offoff == off);
 		/* f is already locked */
 		for(;;){
-			qunlock(f);
+			qunlock(&f->QLock);
 			event = recvul(w->eventc);
-			qlock(f);
+			qlock(&f->QLock);
 			ddprint(2, "readproc unblocked fid %d %lld\n",
 					f->fid, f->dir->qid.path);
 			switch (event & 0xffff){
@@ -538,7 +538,7 @@ flush:
 		assert(f->readers == 0);
 		free(rhdr);
 		w->rhdr = nil;
-		qunlock(f);
+		qunlock(&f->QLock);
 		sendp(procchan, w);
 	}
 	threadexits(nil);
@@ -627,7 +627,7 @@ rread(Fid *f)
 	if(f->dir == &dirs[Qaudioctl]){
 		Fcall *hdr;
 
-		qlock(f);
+		qlock(&f->QLock);
 		a = f->fiddata;
 		if(off - a->offoff < 0){
 			/* there was a seek */
@@ -640,14 +640,14 @@ rread(Fid *f)
 				rhdr.count = a->ns - (off - a->offoff);
 				if(rhdr.count > cnt)
 					rhdr.count = cnt;
-				qunlock(f);
+				qunlock(&f->QLock);
 				return nil;
 			}
 			if(a->offoff != off){
 				a->ns = 0;
 				a->offoff = off;
 				rhdr.count = 0;
-				qunlock(f);
+				qunlock(&f->QLock);
 				return nil;
 			}
 		} while(makeaudioctldata(f) != 0);
@@ -799,7 +799,7 @@ rclunk(Fid *f)
 {
 	Audioctldata *a;
 
-	qlock(f);
+	qlock(&f->QLock);
 	f->flags &= ~(Open|Busy);
 	assert(f->readers ==0);
 	if(f->fiddata){
@@ -809,7 +809,7 @@ rclunk(Fid *f)
 		free(a);
 		f->fiddata = nil;
 	}
-	qunlock(f);
+	qunlock(&f->QLock);
 	return 0;
 }
 
@@ -825,14 +825,14 @@ rstat(Fid *f)
 	Audioctldata *a;
 
 	if(f->dir == &dirs[Qaudioctl]){
-		qlock(f);
+		qlock(&f->QLock);
 		if(f->fiddata == nil)
 			f->fiddata = allocaudioctldata();
 		a = f->fiddata;
 		if(a->ns == 0)
 			makeaudioctldata(f);
 		f->dir->length = a->offoff + a->ns;
-		qunlock(f);
+		qunlock(&f->QLock);
 	}
 	rhdr.nstat = convD2M(f->dir, mbuf, messagesize - IOHDRSZ);
 	rhdr.stat = mbuf;

+ 0 - 1
sys/src/libusb/build.json

@@ -1,7 +1,6 @@
 {
 	"Libusb": {
 		"Cflags": [
-		    "-fplan9-extensions",
 			"-fasm",
 			"-Werror"
 		],

+ 56 - 56
sys/src/libusb/disk/disk.c

@@ -135,28 +135,28 @@ umscapacity(Umsc *lun)
 
 	lun->blocks = 0;
 	lun->capacity = 0;
-	lun->lbsize = 0;
+	lun->ScsiReq.lbsize = 0;
 	memset(data, 0, sizeof data);
-	if(SRrcapacity(lun, data) < 0 && SRrcapacity(lun, data)  < 0)
+	if(SRrcapacity(&lun->ScsiReq, data) < 0 && SRrcapacity(&lun->ScsiReq, data)  < 0)
 		return -1;
 	lun->blocks = GETBELONG(data);
-	lun->lbsize = GETBELONG(data+4);
+	lun->ScsiReq.lbsize = GETBELONG(data+4);
 	if(lun->blocks == 0xFFFFFFFF){
-		if(SRrcapacity16(lun, data) < 0){
-			lun->lbsize = 0;
+		if(SRrcapacity16(&lun->ScsiReq, data) < 0){
+			lun->ScsiReq.lbsize = 0;
 			lun->blocks = 0;
 			return -1;
 		}else{
-			lun->lbsize = GETBELONG(data + 8);
+			lun->ScsiReq.lbsize = GETBELONG(data + 8);
 			lun->blocks = (uint64_t)GETBELONG(data)<<32 |
 				GETBELONG(data + 4);
 		}
 	}
 	lun->blocks++; /* SRcapacity returns LBA of last block */
-	lun->capacity = (int64_t)lun->blocks * lun->lbsize;
+	lun->capacity = (int64_t)lun->blocks * lun->ScsiReq.lbsize;
 	if(diskdebug)
 		fprint(2, "disk: logical block size %lud, # blocks %llud\n",
-			lun->lbsize, lun->blocks);
+			lun->ScsiReq.lbsize, lun->blocks);
 	return 0;
 }
 
@@ -174,14 +174,14 @@ umsinit(Ums *ums)
 	for(i = 0; i <= ums->maxlun; i++){
 		lun = &ums->lun[i];
 		lun->ums = ums;
-		lun->umsc = lun;
-		lun->lun = i;
-		lun->flags = Fopen | Fusb | Frw10;
-		if(SRinquiry(lun) < 0 && SRinquiry(lun) < 0){
+		lun->ScsiReq.umsc = lun;
+		lun->ScsiReq.lun = i;
+		lun->ScsiReq.flags = Fopen | Fusb | Frw10;
+		if(SRinquiry(&lun->ScsiReq) < 0 && SRinquiry(&lun->ScsiReq) < 0){
 			dprint(2, "disk: lun %d inquiry failed\n", i);
 			continue;
 		}
-		switch(lun->inquiry[0]){
+		switch(lun->ScsiReq.inquiry[0]){
 		case Devdir:
 		case Devworm:		/* a little different than the others */
 		case Devcd:
@@ -189,16 +189,16 @@ umsinit(Ums *ums)
 			break;
 		default:
 			fprint(2, "disk: lun %d is not a disk (type %#02x)\n",
-				i, lun->inquiry[0]);
+				i, lun->ScsiReq.inquiry[0]);
 			continue;
 		}
-		SRstart(lun, 1);
+		SRstart(&lun->ScsiReq, 1);
 		/*
 		 * we ignore the device type reported by inquiry.
 		 * Some devices return a wrong value but would still work.
 		 */
 		some++;
-		lun->inq = smprint("%.48s", (char *)lun->inquiry+8);
+		lun->inq = smprint("%.48s", (char *)lun->ScsiReq.inquiry+8);
 		umscapacity(lun);
 	}
 	if(some == 0){
@@ -227,7 +227,7 @@ umsrequest(Umsc *umsc, ScsiPtr *cmd, ScsiPtr *data, int *status)
 	cbw.tag = ++ums->seq;
 	cbw.datalen = data->count;
 	cbw.flags = data->write? CbwDataOut: CbwDataIn;
-	cbw.lun = umsc->lun;
+	cbw.lun = umsc->ScsiReq.lun;
 	if(cmd->count < 1 || cmd->count > 16)
 		fprint(2, "disk: umsrequest: bad cmd count: %ld\n", cmd->count);
 
@@ -424,10 +424,10 @@ setup(Umsc *lun, char *data, int count, int64_t offset)
 	int32_t nb, lbsize, lbshift, lbmask;
 	uint64_t bno;
 
-	if(count < 0 || lun->lbsize <= 0 && umscapacity(lun) < 0 ||
-	    lun->lbsize == 0)
+	if(count < 0 || lun->ScsiReq.lbsize <= 0 && umscapacity(lun) < 0 ||
+	    lun->ScsiReq.lbsize == 0)
 		return -1;
-	lbsize = lun->lbsize;
+	lbsize = lun->ScsiReq.lbsize;
 	assert(ispow2(lbsize));
 	lbshift = log2(lbsize);
 	lbmask = lbsize - 1;
@@ -443,7 +443,7 @@ setup(Umsc *lun, char *data, int count, int64_t offset)
 	if(bno >= lun->blocks || nb == 0)
 		return 0;
 
-	lun->offset = bno;
+	lun->ScsiReq.offset = bno;
 	lun->off = offset & lbmask;		/* offset % lbsize */
 	if(lun->off == 0 && (count & lbmask) == 0)
 		lun->bufp = data;
@@ -477,7 +477,7 @@ dread(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 	ums = fs->dev->aux;
 	lun = fs->aux;
 
-	qlock(ums);
+	qlock(&ums->QLock);
 	switch(path){
 	case Qdir:
 		count = usbdirread(fs, q, data, count, offset, dirgen, nil);
@@ -487,40 +487,40 @@ dread(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 		 * Some usb disks need an extra opportunity to divulge their
 		 * capacity (e.g. M-Systems/SanDisk 1GB flash drive).
 		 */
-		if(lun->lbsize <= 0)
+		if(lun->ScsiReq.lbsize <= 0)
 			umscapacity(lun);
 
 		s = buf;
 		e = buf + sizeof(buf);
-		if(lun->flags & Finqok)
+		if(lun->ScsiReq.flags & Finqok)
 			s = seprint(s, e, "inquiry %s lun %ld: %s\n",
 				fs->dev->dir, lun - &ums->lun[0], lun->inq);
 		if(lun->blocks > 0)
 			s = seprint(s, e, "geometry %llud %ld\n",
-				lun->blocks, lun->lbsize);
+				lun->blocks, lun->ScsiReq.lbsize);
 		count = usbreadbuf(data, count, offset, buf, s - buf);
 		break;
 	case Qraw:
-		if(lun->lbsize <= 0 && umscapacity(lun) < 0){
+		if(lun->ScsiReq.lbsize <= 0 && umscapacity(lun) < 0){
 			count = -1;
 			break;
 		}
 		switch(lun->phase){
 		case Pcmd:
-			qunlock(ums);
+			qunlock(&ums->QLock);
 			werrstr("phase error");
 			return -1;
 		case Pdata:
-			lun->data.p = data;
-			lun->data.count = count;
-			lun->data.write = 0;
-			count = umsrequest(lun,&lun->cmd,&lun->data,&lun->status);
+			lun->ScsiReq.data.p = data;
+			lun->ScsiReq.data.count = count;
+			lun->ScsiReq.data.write = 0;
+			count = umsrequest(lun,&lun->ScsiReq.cmd,&lun->ScsiReq.data,&lun->ScsiReq.status);
 			lun->phase = Pstatus;
 			if(count < 0)
-				lun->lbsize = 0;  /* medium may have changed */
+				lun->ScsiReq.lbsize = 0;  /* medium may have changed */
 			break;
 		case Pstatus:
-			n = snprint(buf, sizeof buf, "%11.0ud ", lun->status);
+			n = snprint(buf, sizeof buf, "%11.0ud ", lun->ScsiReq.status);
 			count = usbreadbuf(data, count, 0LL, buf, n);
 			lun->phase = Pcmd;
 			break;
@@ -530,9 +530,9 @@ dread(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 		count = setup(lun, data, count, offset);
 		if (count <= 0)
 			break;
-		n = SRread(lun, lun->bufp, lun->nb * lun->lbsize);
+		n = SRread(&lun->ScsiReq, lun->bufp, lun->nb * lun->ScsiReq.lbsize);
 		if(n < 0){
-			lun->lbsize = 0;	/* medium may have changed */
+			lun->ScsiReq.lbsize = 0;	/* medium may have changed */
 			count = -1;
 		} else if (lun->bufp == data)
 			count = n;
@@ -548,7 +548,7 @@ dread(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 		}
 		break;
 	}
-	qunlock(ums);
+	qunlock(&ums->QLock);
 	return count;
 }
 
@@ -565,7 +565,7 @@ dwrite(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 	lun = fs->aux;
 	path = fid->qid.path & ~fs->qid;
 
-	qlock(ums);
+	qlock(&ums->QLock);
 	switch(path){
 	default:
 		werrstr(Eperm);
@@ -575,31 +575,31 @@ dwrite(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 		dprint(2, "usb/disk: ctl ignored\n");
 		break;
 	case Qraw:
-		if(lun->lbsize <= 0 && umscapacity(lun) < 0){
+		if(lun->ScsiReq.lbsize <= 0 && umscapacity(lun) < 0){
 			count = -1;
 			break;
 		}
 		switch(lun->phase){
 		case Pcmd:
 			if(count != 6 && count != 10){
-				qunlock(ums);
+				qunlock(&ums->QLock);
 				werrstr("bad command length");
 				return -1;
 			}
 			memmove(lun->rawcmd, data, count);
-			lun->cmd.p = lun->rawcmd;
-			lun->cmd.count = count;
-			lun->cmd.write = 1;
+			lun->ScsiReq.cmd.p = lun->rawcmd;
+			lun->ScsiReq.cmd.count = count;
+			lun->ScsiReq.cmd.write = 1;
 			lun->phase = Pdata;
 			break;
 		case Pdata:
-			lun->data.p = data;
-			lun->data.count = count;
-			lun->data.write = 1;
-			count = umsrequest(lun,&lun->cmd,&lun->data,&lun->status);
+			lun->ScsiReq.data.p = data;
+			lun->ScsiReq.data.count = count;
+			lun->ScsiReq.data.write = 1;
+			count = umsrequest(lun,&lun->ScsiReq.cmd,&lun->ScsiReq.data,&lun->ScsiReq.status);
 			lun->phase = Pstatus;
 			if(count < 0)
-				lun->lbsize = 0;  /* medium may have changed */
+				lun->ScsiReq.lbsize = 0;  /* medium may have changed */
 			break;
 		case Pstatus:
 			lun->phase = Pcmd;
@@ -613,11 +613,11 @@ dwrite(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 		count = setup(lun, data, count, offset);
 		if (count <= 0)
 			break;
-		bno = lun->offset;
+		bno = lun->ScsiReq.offset;
 		if (lun->bufp == lun->buf) {
-			count = SRread(lun, lun->bufp, lun->nb * lun->lbsize);
+			count = SRread(&lun->ScsiReq, lun->bufp, lun->nb * lun->ScsiReq.lbsize);
 			if(count < 0) {
-				lun->lbsize = 0;  /* medium may have changed */
+				lun->ScsiReq.lbsize = 0;  /* medium may have changed */
 				break;
 			}
 			/*
@@ -630,10 +630,10 @@ dwrite(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 				memmove(lun->bufp + lun->off, data, len);
 		}
 
-		lun->offset = bno;
-		count = SRwrite(lun, lun->bufp, lun->nb * lun->lbsize);
+		lun->ScsiReq.offset = bno;
+		count = SRwrite(&lun->ScsiReq, lun->bufp, lun->nb * lun->ScsiReq.lbsize);
 		if(count < 0)
-			lun->lbsize = 0;	/* medium may have changed */
+			lun->ScsiReq.lbsize = 0;	/* medium may have changed */
 		else{
 			if(lun->off + len > count)
 				count -= lun->off; /* short write */
@@ -645,7 +645,7 @@ dwrite(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 		}
 		break;
 	}
-	qunlock(ums);
+	qunlock(&ums->QLock);
 	return count;
 }
 
@@ -686,7 +686,7 @@ findendpoints(Ums *ums)
 		return -1;
 	}
 	if(epout == epin){
-		incref(ums->epin);
+		incref(&ums->epin->Ref);
 		ums->epout = ums->epin;
 	}else
 		ums->epout = openep(ums->dev, epout);
@@ -798,7 +798,7 @@ diskmain(Dev *dev, int argc, char **argv)
 		lun->fs = diskfs;
 		snprint(lun->fs.name, sizeof(lun->fs.name), "sdU%d.%d", devid, i);
 		lun->fs.dev = dev;
-		incref(dev);
+		incref(&dev->Ref);
 		lun->fs.aux = lun;
 		usbfsadd(&lun->fs);
 	}

+ 11 - 11
sys/src/libusb/ether/asix.c

@@ -364,7 +364,7 @@ asixbread(Ether *e, Buf *bp)
 	uint32_t hd;
 	Buf *rbp;
 
-	rbp = e->aux;
+	rbp = e->Etherops.aux;
 	if(rbp == nil || rbp->ndata < 4){
 		rbp->rp = rbp->data;
 		rbp->ndata = read(e->epin->dfd, rbp->rp, sizeof(bp->data));
@@ -464,8 +464,8 @@ static void
 asixfree(Ether *ether)
 {
 	deprint(2, "%s: aixfree %#p\n", argv0, ether);
-	free(ether->aux);
-	ether->aux = nil;
+	free(ether->Etherops.aux);
+	ether->Etherops.aux = nil;
 }
 
 int
@@ -483,14 +483,14 @@ asixreset(Ether *ether)
 				return -1;
 			}
 			deprint(2, "%s: asix reset done\n", argv0);
-			ether->name = "asix";
-			ether->aux = emallocz(sizeof(Buf), 1);
-			ether->bufsize = Hdrsize+Maxpkt;
-			ether->bread = asixbread;
-			ether->bwrite = asixbwrite;
-			ether->free = asixfree;
-			ether->promiscuous = asixpromiscuous;
-			ether->multicast = asixmulticast;
+			ether->Etherops.name = "asix";
+			ether->Etherops.aux = emallocz(sizeof(Buf), 1);
+			ether->Etherops.bufsize = Hdrsize+Maxpkt;
+			ether->Etherops.bread = asixbread;
+			ether->Etherops.bwrite = asixbwrite;
+			ether->Etherops.free = asixfree;
+			ether->Etherops.promiscuous = asixpromiscuous;
+			ether->Etherops.multicast = asixmulticast;
 			ether->mbps = 100;	/* BUG */
 			return 0;
 		}

+ 59 - 59
sys/src/libusb/ether/ether.c

@@ -159,9 +159,9 @@ freebuf(Ether *e, Buf *bp)
 {
 	if(0)deprint(2, "%s: freebuf %#p\n", argv0, bp);
 	if(bp != nil){
-		qlock(e);
+		qlock(&e->QLock);
 		e->nbufs--;
-		qunlock(e);
+		qunlock(&e->QLock);
 		sendp(e->bc, bp);
 	}
 }
@@ -173,14 +173,14 @@ allocbuf(Ether *e)
 
 	bp = nbrecvp(e->bc);
 	if(bp == nil){
-		qlock(e);
+		qlock(&e->QLock);
 		if(e->nabufs < Nbufs){
 			bp = emallocz(sizeof(Buf), 1);
 			e->nabufs++;
 			setmalloctag(bp, getcallerpc());
 			deprint(2, "%s: %d buffers\n", argv0, e->nabufs);
 		}
-		qunlock(e);
+		qunlock(&e->QLock);
 	}
 	if(bp == nil){
 		deprint(2, "%s: blocked waiting for allocbuf\n", argv0);
@@ -189,9 +189,9 @@ allocbuf(Ether *e)
 	bp->rp = bp->data + Hdrsize;
 	bp->ndata = 0;
 	if(0)deprint(2, "%s: allocbuf %#p\n", argv0, bp);
-	qlock(e);
+	qlock(&e->QLock);
 	e->nbufs++;
-	qunlock(e);
+	qunlock(&e->QLock);
 	return bp;
 }
 
@@ -201,25 +201,25 @@ newconn(Ether *e)
 	int i;
 	Conn *c;
 
-	qlock(e);
+	qlock(&e->QLock);
 	for(i = 0; i < nelem(e->conns); i++){
 		c = e->conns[i];
-		if(c == nil || c->ref == 0){
+		if(c == nil || c->Ref.ref == 0){
 			if(c == nil){
 				c = emallocz(sizeof(Conn), 1);
 				c->rc = chancreate(sizeof(Buf*), 16);
 				c->nb = i;
 			}
-			c->ref = 1;
+			c->Ref.ref = 1;
 			if(i == e->nconns)
 				e->nconns++;
 			e->conns[i] = c;
 			deprint(2, "%s: newconn %d\n", argv0, i);
-			qunlock(e);
+			qunlock(&e->QLock);
 			return c;
 		}
 	}
-	qunlock(e);
+	qunlock(&e->QLock);
 	return nil;
 }
 
@@ -264,7 +264,7 @@ dumpframe(char *tag, void *p, int n)
 static char*
 seprintstats(char *s, char *se, Ether *e)
 {
-	qlock(e);
+	qlock(&e->QLock);
 	s = seprint(s, se, "in: %ld\n", e->nin);
 	s = seprint(s, se, "out: %ld\n", e->nout);
 	s = seprint(s, se, "input errs: %ld\n", e->nierrs);
@@ -274,7 +274,7 @@ seprintstats(char *s, char *se, Ether *e)
 	s = seprint(s, se, "addr: ");
 	s = seprintaddr(s, se, e->addr);
 	s = seprint(s, se, "\n");
-	qunlock(e);
+	qunlock(&e->QLock);
 	return s;
 }
 
@@ -284,7 +284,7 @@ seprintifstats(char *s, char *se, Ether *e)
 	int i;
 	Conn *c;
 
-	qlock(e);
+	qlock(&e->QLock);
 	s = seprint(s, se, "ctlr id: %#x\n", e->cid);
 	s = seprint(s, se, "phy: %#x\n", e->phy);
 	s = seprint(s, se, "exiting: %s\n", e->exiting ? "y" : "n");
@@ -295,14 +295,14 @@ seprintifstats(char *s, char *se, Ether *e)
 		c = e->conns[i];
 		if(c == nil)
 			continue;
-		if(c->ref == 0)
+		if(c->Ref.ref == 0)
 			s = seprint(s, se, "c[%d]: free\n", i);
 		else{
 			s = seprint(s, se, "c[%d]: refs %ld t %#x h %d p %d\n",
-				c->nb, c->ref, c->type, c->headersonly, c->prom);
+				c->nb, c->Ref.ref, c->type, c->headersonly, c->prom);
 		}
 	}
-	qunlock(e);
+	qunlock(&e->QLock);
 	return s;
 }
 
@@ -322,15 +322,15 @@ getconn(Ether *e, int i, int idleok)
 {
 	Conn *c;
 
-	qlock(e);
+	qlock(&e->QLock);
 	if(i < 0 || i >= e->nconns)
 		c = nil;
 	else{
 		c = e->conns[i];
-		if(idleok == 0 && c != nil && c->ref == 0)
+		if(idleok == 0 && c != nil && c->Ref.ref == 0)
 			c = nil;
 	}
-	qunlock(e);
+	qunlock(&e->QLock);
 	return c;
 }
 
@@ -510,7 +510,7 @@ fsopen(Usbfs *fs, Fid *fid, int omode)
 		c = getconn(e, qnum(qid), 1);
 		if(c == nil)
 			sysfatal("usb: ether: fsopen bug");
-		incref(c);
+		incref(&c->Ref);
 		break;
 	}
 	etherdump(e);
@@ -520,8 +520,8 @@ fsopen(Usbfs *fs, Fid *fid, int omode)
 static int
 prom(Ether *e, int set)
 {
-	if(e->promiscuous != nil)
-		return e->promiscuous(e, set);
+	if(e->Etherops.promiscuous != nil)
+		return e->Etherops.promiscuous(e, set);
 	return 0;
 }
 
@@ -547,15 +547,15 @@ fsclunk(Usbfs *fs, Fid *fid)
 			c = getconn(e, qnum(qid), 0);
 			if(c == nil)
 				sysfatal("usb: ether: fsopen bug");
-			if(decref(c) == 0){
+			if(decref(&c->Ref) == 0){
 				while((bp = nbrecvp(c->rc)) != nil)
 					freebuf(e, bp);
-				qlock(e);
+				qlock(&e->QLock);
 				if(c->prom != 0)
 					if(decref(&e->prom) == 0)
 						prom(e, 0);
 				c->prom = c->type = 0;
-				qunlock(e);
+				qunlock(&e->QLock);
 			}
 		}
 		break;
@@ -623,8 +623,8 @@ fsread(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 		/* BUG */
 	case Qifstats:
 		s = seprintifstats(s, se, e);
-		if(e->seprintstats != nil)
-			s = e->seprintstats(s, se, e);
+		if(e->Etherops.seprintstats != nil)
+			s = e->Etherops.seprintstats(s, se, e);
 		count = usbreadbuf(data, count, offset, buf, s - buf);
 		break;
 	case Qnstats:
@@ -675,7 +675,7 @@ typeinuse(Ether *e, int t)
 	int i;
 
 	for(i = 0; i < e->nconns; i++)
-		if(e->conns[i]->ref > 0 && e->conns[i]->type == t)
+		if(e->conns[i]->Ref.ref > 0 && e->conns[i]->type == t)
 			return 1;
 	return 0;
 }
@@ -695,14 +695,14 @@ etherctl(Ether *e, Conn *c, char *buf)
 	deprint(2, "%s: etherctl: %s\n", argv0, buf);
 	if(strncmp(buf, "connect ", 8) == 0){
 		t = atoi(buf+8);
-		qlock(e);
+		qlock(&e->QLock);
 		if(typeinuse(e, t)){
 			werrstr("type already in use");
-			qunlock(e);
+			qunlock(&e->QLock);
 			return -1;
 		}
 		c->type = atoi(buf+8);
-		qunlock(e);
+		qunlock(&e->QLock);
 		return 0;
 	}
 	if(strncmp(buf, "nonblocking", 11) == 0){
@@ -728,19 +728,19 @@ etherctl(Ether *e, Conn *c, char *buf)
 			werrstr("bad address");
 			return -1;
 		}
-		if(e->multicast == nil)
+		if(e->Etherops.multicast == nil)
 			return 0;
 		if(strncmp(buf, "add", 3) == 0){
 			e->nmcasts++;
-			return e->multicast(e, addr, 1);
+			return e->Etherops.multicast(e, addr, 1);
 		}else{
 			e->nmcasts--;
-			return e->multicast(e, addr, 0);
+			return e->Etherops.multicast(e, addr, 0);
 		}
 	}
 
-	if(e->ctl != nil)
-		return e->ctl(e, buf);
+	if(e->Etherops.ctl != nil)
+		return e->Etherops.ctl(e, buf);
 	werrstr(Ebadctl);
 	return -1;
 }
@@ -844,7 +844,7 @@ openeps(Ether *e, int epin, int epout)
 		return -1;
 	}
 	if(epout == epin){
-		incref(e->epin);
+		incref(&e->epin->Ref);
 		e->epout = e->epin;
 	}else
 		e->epout = openep(e->dev, epout);
@@ -911,8 +911,8 @@ etherfree(Ether *e)
 	int i;
 	Buf *bp;
 
-	if(e->free != nil)
-		e->free(e);
+	if(e->Etherops.free != nil)
+		e->Etherops.free(e);
 	closedev(e->epin);
 	closedev(e->epout);
 	if(e->rc == nil){	/* not really started */
@@ -947,7 +947,7 @@ etherdevfree(void *a)
 static int
 cwantsbp(Conn *c, Buf *bp)
 {
-	if(c->ref != 0 && (c->prom != 0 || c->type < 0 || c->type == bp->type))
+	if(c->Ref.ref != 0 && (c->prom != 0 || c->type < 0 || c->type == bp->type))
 		return 1;
 	return 0;
 }
@@ -968,7 +968,7 @@ etherwriteproc(void *a)
 			break;
 		}
 		e->nout++;
-		if(e->bwrite(e, bp) < 0)
+		if(e->Etherops.bwrite(e, bp) < 0)
 			e->noerrs++;
 		if(isloopback(e, bp) && e->exiting == 0)
 			sendp(e->rc, bp); /* send to input queue */
@@ -1015,7 +1015,7 @@ etherreadproc(void *a)
 		bp = nbrecvp(e->rc);
 		if(bp == nil){
 			bp = allocbuf(e);	/* leak() may think we leak */
-			if(e->bread(e, bp) < 0){
+			if(e->Etherops.bread(e, bp) < 0){
 				freebuf(e, bp);
 				break;
 			}
@@ -1166,8 +1166,8 @@ kernelproxy(Ether *e)
 	close(e->epout->dfd);
 	seprintaddr(eaddr, eaddr+sizeof(eaddr), e->addr);
 	n = fprint(ctlfd, "bind %s #u/usb/ep%d.%d/data #u/usb/ep%d.%d/data %s %d %d",
-		e->name, e->dev->id, e->epin->id, e->dev->id, e->epout->id,
-		eaddr, e->bufsize, e->epout->maxpkt);
+		e->Etherops.name, e->dev->id, e->epin->id, e->dev->id, e->epout->id,
+		eaddr, e->Etherops.bufsize, e->epout->maxpkt);
 	if(n < 0){
 		deprint(2, "%s: etherusb bind #l0: %r\n", argv0);
 		opendevdata(e->epin, OREAD);
@@ -1211,23 +1211,23 @@ ethermain(Dev *dev, int argc, char **argv)
 	e->dev = dev;
 	dev->free = etherdevfree;
 	memmove(e->addr, ea, Eaddrlen);
-	e->name = "cdc";
+	e->Etherops.name = "cdc";
 
 	for(i = 0; i < nelem(ethers); i++)
 		if(ethers[i](e) == 0)
 			break;
 	if(i == nelem(ethers))
 		return -1;
-	if(e->init == nil)
-		e->init = etherinit;
-	if(e->init(e, &epin, &epout) < 0)
+	if(e->Etherops.init == nil)
+		e->Etherops.init = etherinit;
+	if(e->Etherops.init(e, &epin, &epout) < 0)
 		return -1;
-	if(e->bwrite == nil)
-		e->bwrite = etherbwrite;
-	if(e->bread == nil)
-		e->bread = etherbread;
-	if(e->bufsize == 0)
-		e->bufsize = Maxpkt;
+	if(e->Etherops.bwrite == nil)
+		e->Etherops.bwrite = etherbwrite;
+	if(e->Etherops.bread == nil)
+		e->Etherops.bread = etherbread;
+	if(e->Etherops.bufsize == 0)
+		e->Etherops.bufsize = Maxpkt;
 
 	if(openeps(e, epin, epout) < 0)
 		return -1;
@@ -1240,12 +1240,12 @@ ethermain(Dev *dev, int argc, char **argv)
 	e->bc = chancreate(sizeof(Buf*), Nbufs);
 	e->rc = chancreate(sizeof(Buf*), Nconns/2);
 	e->wc = chancreate(sizeof(Buf*), Nconns*2);
-	incref(e->dev);
+	incref(&e->dev->Ref);
 	proccreate(etherwriteproc, e, 16*1024);
-	incref(e->dev);
+	incref(&e->dev->Ref);
 	proccreate(etherreadproc, e, 16*1024);
-	deprint(2, "%s: dev ref %ld\n", argv0, dev->ref);
-	incref(e->dev);
+	deprint(2, "%s: dev ref %ld\n", argv0, dev->Ref.ref);
+	incref(&e->dev->Ref);
 	usbfsadd(&e->fs);
 	return 0;
 }

+ 14 - 14
sys/src/libusb/ether/smsc.c

@@ -280,7 +280,7 @@ smscbread(Ether *e, Buf *bp)
 	int n, m;
 	Buf *rbp;
 
-	rbp = e->aux;
+	rbp = e->Etherops.aux;
 	if(rbp->ndata < 4){
 		rbp->rp = rbp->data;
 		rbp->ndata = read(e->epin->dfd, rbp->rp, Doburst? Hsburst*512:
@@ -368,8 +368,8 @@ smscmulticast(Ether *e, uint8_t *addr, int on)
 static void
 smscfree(Ether *ether)
 {
-	free(ether->aux);
-	ether->aux = nil;
+	free(ether->Etherops.aux);
+	ether->Etherops.aux = nil;
 }
 
 int
@@ -387,20 +387,20 @@ smscreset(Ether *ether)
 				return -1;
 			}
 			deprint(2, "%s: smsc reset done\n", argv0);
-			ether->name = "smsc";
+			ether->Etherops.name = "smsc";
 			if(Doburst){
-				ether->bufsize = Hsburst*512;
-				ether->aux = emallocz(sizeof(Buf) +
-					ether->bufsize - Maxpkt, 1);
+				ether->Etherops.bufsize = Hsburst*512;
+				ether->Etherops.aux = emallocz(sizeof(Buf) +
+					ether->Etherops.bufsize - Maxpkt, 1);
 			}else{
-				ether->bufsize = Maxpkt;
-				ether->aux = emallocz(sizeof(Buf), 1);
+				ether->Etherops.bufsize = Maxpkt;
+				ether->Etherops.aux = emallocz(sizeof(Buf), 1);
 			}
-			ether->free = smscfree;
-			ether->bread = smscbread;
-			ether->bwrite = smscbwrite;
-			ether->promiscuous = smscpromiscuous;
-			ether->multicast = smscmulticast;
+			ether->Etherops.free = smscfree;
+			ether->Etherops.bread = smscbread;
+			ether->Etherops.bwrite = smscbwrite;
+			ether->Etherops.promiscuous = smscpromiscuous;
+			ether->Etherops.multicast = smscmulticast;
 			ether->mbps = 100;	/* BUG */
 			return 0;
 		}

+ 2 - 2
sys/src/libusb/kb/kb.c

@@ -685,7 +685,7 @@ kbstart(Dev *d, Ep *ep, Kin *in, void (*f)(void*), KDev *kd)
 		return;
 	}
 
-	incref(d);
+	incref(&d->Ref);
 	proccreate(f, kd, Stack);
 }
 
@@ -738,7 +738,7 @@ kbmain(Dev *d, int argc, char* argv[])
 	USED(devid);
 	ud = d->usb;
 	d->aux = nil;
-	dprint(2, "kb: main: dev %s ref %ld\n", d->dir, d->ref);
+	dprint(2, "kb: main: dev %s ref %ld\n", d->dir, d->Ref.ref);
 
 	if(kena)
 		for(i = 0; i < nelem(ud->ep); i++)

+ 2 - 2
sys/src/libusb/lib/dev.c

@@ -108,7 +108,7 @@ opendev(char *fn)
 	if(access("/dev/usb", AEXIST) < 0 && bind("#u", "/dev", MBEFORE) < 0)
 		return nil;
 	d = emallocz(sizeof(Dev), 1);
-	incref(d);
+	incref(&d->Ref);
 
 	l = strlen(fn);
 	d->dfd = -1;
@@ -304,7 +304,7 @@ closedev(Dev *d)
 	int i;
 	Usbdev *ud;
 
-	if(d==nil || decref(d) != 0)
+	if(d==nil || decref(&d->Ref) != 0)
 		return;
 	dprint(2, "%s: closedev %#p %s\n", argv0, d, d->dir);
 	if(d->free != nil)

+ 2 - 2
sys/src/libusb/lib/dump.c

@@ -143,11 +143,11 @@ Ufmt(Fmt *f)
 	s = seprint(s, e, "%s", d->dir);
 	ud = d->usb;
 	if(ud == nil)
-		return fmtprint(f, "%s %ld refs\n", buf, d->ref);
+		return fmtprint(f, "%s %ld refs\n", buf, d->Ref.ref);
 	s = seprint(s, e, " csp %s.%uld.%uld",
 		classname(Class(ud->csp)), Subclass(ud->csp), Proto(ud->csp));
 	s = seprint(s, e, " vid %#ux did %#ux", ud->vid, ud->did);
-	s = seprint(s, e, " refs %ld\n", d->ref);
+	s = seprint(s, e, " refs %ld\n", d->Ref.ref);
 	s = seprint(s, e, "\t%s %s %s\n", ud->vendor, ud->product, ud->serial);
 	for(i = 0; i < Nconf; i++){
 		if(ud->conf[i] == nil)

+ 10 - 10
sys/src/libusb/lib/fsdir.c

@@ -64,7 +64,7 @@ usbfsdirdump(void)
 		if(fs[i] != nil)
 			if(fs[i]->dev != nil)
 				fprint(2, "%s\t%s dev %#p refs %ld\n",
-					argv0, fs[i]->name, fs[i]->dev, fs[i]->dev->ref);
+					argv0, fs[i]->name, fs[i]->dev, fs[i]->dev->Ref.ref);
 			else
 				fprint(2, "%s:\t%s\n", argv0, fs[i]->name);
 	qunlock(&fslck);
@@ -105,7 +105,7 @@ usbfsdelnth(int i)
 		dprint(2, "%s: fsdel %s", argv0, fs[i]->name);
 		if(fs[i]->dev != nil){
 			dprint(2, " dev %#p ref %ld\n",
-				fs[i]->dev, fs[i]->dev->ref);
+				fs[i]->dev, fs[i]->dev->Ref.ref);
 		}else
 			dprint(2, "no dev\n");
 		if(fs[i]->end != nil)
@@ -170,7 +170,7 @@ fsclone(Usbfs*_1, Fid *o, Fid *n)
 	if(qd != Dtop && fs[qd] != nil && fs[qd]->clone != nil){
 		dev = fs[qd]->dev;
 		if(dev != nil)
-			incref(dev);
+			incref(&dev->Ref);
 		xfsclone = fs[qd]->clone;
 	}
 	qunlock(&fslck);
@@ -213,7 +213,7 @@ fswalk(Usbfs*_1, Fid *fid, char *name)
 		}
 		dev = fs[qd]->dev;
 		if(dev != nil)
-			incref(dev);
+			incref(&dev->Ref);
 		xfswalk = fs[qd]->walk;
 		qunlock(&fslck);
 		rc = xfswalk(fs[qd], fid, name);
@@ -254,7 +254,7 @@ fsopen(Usbfs*_1, Fid *fid, int mode)
 	}
 	dev = fs[qd]->dev;
 	if(dev != nil)
-		incref(dev);
+		incref(&dev->Ref);
 	xfsopen = fs[qd]->open;
 	qunlock(&fslck);
 	if(xfsopen != nil)
@@ -281,7 +281,7 @@ dirgen(Usbfs*_1, Qid _2, int n, Dir *d, void *_3)
 			d->qid.vers = 0;
 			dev = fs[i]->dev;
 			if(dev != nil)
-				incref(dev);
+				incref(&dev->Ref);
 			nm = d->name;
 			fs[i]->stat(fs[i], d->qid, d);
 			d->name = nm;
@@ -317,7 +317,7 @@ fsread(Usbfs*_1, Fid *fid, void *data, int32_t cnt, int64_t off)
 	}
 	dev = fs[qd]->dev;
 	if(dev != nil)
-		incref(dev);
+		incref(&dev->Ref);
 	xfsread = fs[qd]->read;
 	qunlock(&fslck);
 	rc = xfsread(fs[qd], fid, data, cnt, off);
@@ -346,7 +346,7 @@ fswrite(Usbfs*_1, Fid *fid, void *data, int32_t cnt, int64_t off)
 	}
 	dev = fs[qd]->dev;
 	if(dev != nil)
-		incref(dev);
+		incref(&dev->Ref);
 	xfswrite = fs[qd]->write;
 	qunlock(&fslck);
 	rc = xfswrite(fs[qd], fid, data, cnt, off);
@@ -369,7 +369,7 @@ fsclunk(Usbfs*_1, Fid* fid)
 	if(qd != Dtop && fs[qd] != nil){
 		dev=fs[qd]->dev;
 		if(dev != nil)
-			incref(dev);
+			incref(&dev->Ref);
 		xfsclunk = fs[qd]->clunk;
 	}else
 		xfsclunk = nil;
@@ -406,7 +406,7 @@ fsstat(Usbfs*_1, Qid qid, Dir *d)
 	xfsstat = fs[qd]->stat;
 	dev = fs[qd]->dev;
 	if(dev != nil)
-		incref(dev);
+		incref(&dev->Ref);
 	qunlock(&fslck);
 	rc = xfsstat(fs[qd], qid, d);
 	if(dev != nil)

+ 14 - 14
sys/src/libusb/serial/ftdi.c

@@ -550,9 +550,9 @@ ftmatch(Serial *ser, char *info)
 		dsprint(2, "serial: %s %s\n", buf, info);
 		if(strstr(info, buf) != nil){
 			if(ser != nil){
-				qlock(ser);
+				qlock(&ser->QLock);
 				ftgettype(ser);
-				qunlock(ser);
+				qunlock(&ser->QLock);
 			}
 			return 0;
 		}
@@ -607,9 +607,9 @@ wait4data(Serialport *p, uint8_t *data, int count)
 
 	ser = p->s;
 
-	qunlock(ser);
+	qunlock(&ser->QLock);
 	d = sendul(p->w4data, 1);
-	qlock(ser);
+	qlock(&ser->QLock);
 	if(d <= 0)
 		return -1;
 	if(p->ndata >= count)
@@ -642,9 +642,9 @@ wait4write(Serialport *p, uint8_t *data, int count)
 	memmove(b+off, data, count);
 
 	fd = p->epout->dfd;
-	qunlock(ser);
+	qunlock(&ser->QLock);
 	count = write(fd, b, count+off);
-	qlock(ser);
+	qlock(&ser->QLock);
 	free(b);
 	return count;
 }
@@ -710,9 +710,9 @@ epreader(void *u)
 	c = a->c;
 	free(a);
 
-	qlock(ser);	/* this makes the reader wait end of initialization too */
+	qlock(&ser->QLock);	/* this makes the reader wait end of initialization too */
 	dfd = p->epin->dfd;
-	qunlock(ser);
+	qunlock(&ser->QLock);
 
 	ntries = 0;
 	pk = nil;
@@ -728,9 +728,9 @@ Eagain:
 		if(rcount < 0){
 			if(ntries++ > 100)
 				break;
-			qlock(ser);
+			qlock(&ser->QLock);
 			recov = serialrecover(ser, p, nil, "epreader: bulkin error");
-			qunlock(ser);
+			qunlock(&ser->QLock);
 			if(recov >= 0)
 				goto Eagain;
 		}
@@ -751,9 +751,9 @@ Eagain:
 				}
 			}else
 				free(pk);
-			qlock(ser);
+			qlock(&ser->QLock);
 			ser->recover = 0;
-			qunlock(ser);
+			qunlock(&ser->QLock);
 			ntries = 0;
 			pk = nil;
 		}
@@ -790,7 +790,7 @@ statusreader(void *u)
 	a = emallocz(sizeof(Areader), 1);
 	a->p = p;
 	a->c = c;
-	incref(ser->dev);
+	incref(&ser->dev->Ref);
 	proccreate(epreader, a, 16*1024);
 
 	while((pk = recvp(c)) != nil){
@@ -864,7 +864,7 @@ ftinit(Serialport *p)
 		/* 0xb is the mask for lines. plug dependant? */
 		ftdiwrite(p, BMMPSSE|0x0b, 0, FTSETBITMODE);
 	}
-	incref(ser->dev);
+	incref(&ser->dev->Ref);
 	threadcreate(statusreader, p, 8*1024);
 	return 0;
 }

+ 8 - 8
sys/src/libusb/serial/prolific.c

@@ -279,16 +279,16 @@ plinit(Serialport *p)
 		vendorwrite(p, Dcr2Idx|DcrSet, Dcr2InitH);
 
 	plgetparam(p);
-	qunlock(ser);
+	qunlock(&ser->QLock);
 	free(buf);
 	st = emallocz(255, 1);
-	qlock(ser);
+	qlock(&ser->QLock);
 	if(serialdebug)
 		serdumpst(p, st, 255);
 	dsprint(2, st);
 	free(st);
 	/* p gets freed by closedev, the process has a reference */
-	incref(ser->dev);
+	incref(&ser->dev->Ref);
 	proccreate(statusreader, p, 8*1024);
 	return 0;
 }
@@ -369,20 +369,20 @@ plreadstatus(Serialport *p)
 
 	ser = p->s;
 
-	qlock(ser);
+	qlock(&ser->QLock);
 	dsprint(2, "serial: reading from interrupt\n");
 	dfd = p->epintr->dfd;
 
-	qunlock(ser);
+	qunlock(&ser->QLock);
 	nr = read(dfd, buf, sizeof buf);
-	qlock(ser);
+	qlock(&ser->QLock);
 	snprint(err, sizeof err, "%r");
 	dsprint(2, "serial: interrupt read %d %r\n", nr);
 
 	if(nr < 0 && strstr(err, "timed out") == nil){
 		dsprint(2, "serial: need to recover, status read %d %r\n", nr);
 		if(serialrecover(ser, nil, nil, err) < 0){
-			qunlock(ser);
+			qunlock(&ser->QLock);
 			return -1;
 		}
 	}
@@ -403,7 +403,7 @@ plreadstatus(Serialport *p)
 	} else
 		dsprint(2, "serial: bad status read %d\n", nr);
 	dsprint(2, "serial: finished read from interrupt %d\n", nr);
-	qunlock(ser);
+	qunlock(&ser->QLock);
 	return 0;
 }
 

+ 40 - 40
sys/src/libusb/serial/serial.c

@@ -87,8 +87,8 @@ serialdrain(Serialport *p)
 		pipesize = ser->maxwtrans;
 	/* wait for the at least 256-byte pipe to clear */
 	sleep(10 + pipesize/((1 + baud)*1000));
-	if(ser->clearpipes != nil)
-		ser->clearpipes(p);
+	if(ser->Serialops.clearpipes != nil)
+		ser->Serialops.clearpipes(p);
 }
 
 int
@@ -103,8 +103,8 @@ serialreset(Serial *ser)
 		p = &ser->p[i];
 		serialdrain(p);
 	}
-	if(ser->reset != nil)
-		res = ser->reset(ser, nil);
+	if(ser->Serialops.reset != nil)
+		res = ser->Serialops.reset(ser, nil);
 	return res;
 }
 
@@ -145,7 +145,7 @@ serialrecover(Serial *ser, Serialport *p, Dev *ep, char *err)
 	if(ser->recover > 4 && ser->recover < 8)
 		serialfatal(ser);
 	if(ser->recover > 8){
-		ser->reset(ser, p);
+		ser->Serialops.reset(ser, p);
 		return 0;
 	}
 	if(serialreset(ser) < 0)
@@ -166,8 +166,8 @@ serialctl(Serialport *p, char *cmd)
 	nf = tokenize(cmd, f, nelem(f));
 	for(i = 0; i < nf; i++){
 		if(strncmp(f[i], "break", 5) == 0){
-			if(ser->setbreak != nil)
-				ser->setbreak(p, 1);
+			if(ser->Serialops.setbreak != nil)
+				ser->Serialops.setbreak(p, 1);
 			continue;
 		}
 
@@ -209,9 +209,9 @@ serialctl(Serialport *p, char *cmd)
 			break;
 		case 'k':
 			drain++;
-			ser->setbreak(p, 1);
+			ser->Serialops.setbreak(p, 1);
 			sleep(n);
-			ser->setbreak(p, 0);
+			ser->Serialops.setbreak(p, 0);
 			break;
 		case 'l':
 			drain++;
@@ -220,8 +220,8 @@ serialctl(Serialport *p, char *cmd)
 			break;
 		case 'm':
 			drain++;
-			if(ser->modemctl != nil)
-				ser->modemctl(p, n);
+			if(ser->Serialops.modemctl != nil)
+				ser->Serialops.modemctl(p, n);
 			if(n == 0)
 				p->cts = 0;
 			break;
@@ -273,8 +273,8 @@ serialctl(Serialport *p, char *cmd)
 				x = CTLS;
 			else
 				x = CTLQ;
-			if(ser->wait4write != nil)
-				nw = ser->wait4write(p, &x, 1);
+			if(ser->Serialops.wait4write != nil)
+				nw = ser->Serialops.wait4write(p, &x, 1);
 			else
 				nw = write(p->epout->dfd, &x, 1);
 			if(nw != 1){
@@ -294,10 +294,10 @@ serialctl(Serialport *p, char *cmd)
 	if(drain)
 		serialdrain(p);
 	if(lines && !set){
-		if(ser->sendlines != nil && ser->sendlines(p) < 0)
+		if(ser->Serialops.sendlines != nil && ser->Serialops.sendlines(p) < 0)
 			return -1;
 	} else if(set){
-		if(ser->setparam != nil && ser->setparam(p) < 0)
+		if(ser->Serialops.setparam != nil && ser->Serialops.setparam(p) < 0)
 			return -1;
 	}
 	ser->recover = 0;
@@ -346,10 +346,10 @@ serinit(Serialport *p)
 
 	ser = p->s;
 
-	if(ser->init != nil)
-		res = ser->init(p);
-	if(ser->getparam != nil)
-		ser->getparam(p);
+	if(ser->Serialops.init != nil)
+		res = ser->Serialops.init(p);
+	if(ser->Serialops.getparam != nil)
+		ser->Serialops.getparam(p);
 	p->nframeerr = p->nparityerr = p->nbreakerr = p->novererr = 0;
 
 	return res;
@@ -495,7 +495,7 @@ dread(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 
 	buf = emallocz(Serbufsize, 1);
 	err = emallocz(Serbufsize, 1);
-	qlock(ser);
+	qlock(&ser->QLock);
 	switch(path){
 	case Qroot:
 		count = usbdirread(fs, q, data, count, offset, dirgen, p);
@@ -512,12 +512,12 @@ dread(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 				dsprint(2, "serial: reading: %ld\n", count);
 
 			assert(count > 0);
-			if(ser->wait4data != nil)
-				rcount = ser->wait4data(p, data, count);
+			if(ser->Serialops.wait4data != nil)
+				rcount = ser->Serialops.wait4data(p, data, count);
 			else{
-				qunlock(ser);
+				qunlock(&ser->QLock);
 				rcount = read(dfd, data, count);
-				qlock(ser);
+				qlock(&ser->QLock);
 			}
 			/*
 			 * if we encounter a long run of continuous read
@@ -530,7 +530,7 @@ dread(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 				sleep(20);
 				if (good > 0 && errrun > 10000) {
 					/* the line has been dropped; give up */
-					qunlock(ser);
+					qunlock(&ser->QLock);
 					fprint(2, "%s: line %s is gone: %r\n",
 						argv0, p->fs.name);
 					threadexitsall("serial line gone");
@@ -563,7 +563,7 @@ dread(Usbfs *fs, Fid *fid, void *data, int32_t count, int64_t offset)
 	}
 	if(count >= 0)
 		ser->recover = 0;
-	qunlock(ser);
+	qunlock(&ser->QLock);
 	free(err);
 	free(buf);
 	return count;
@@ -580,14 +580,14 @@ altwrite(Serialport *p, uint8_t *buf, int32_t count)
 	do{
 		dsprint(2, "serial: write to bulk %ld\n", count);
 
-		if(ser->wait4write != nil)
+		if(ser->Serialops.wait4write != nil)
 			/* unlocked inside later */
-			nw = ser->wait4write(p, buf, count);
+			nw = ser->Serialops.wait4write(p, buf, count);
 		else{
 			dfd = p->epout->dfd;
-			qunlock(ser);
+			qunlock(&ser->QLock);
 			nw = write(dfd, buf, count);
-			qlock(ser);
+			qlock(&ser->QLock);
 		}
 		rerrstr(err, sizeof err);
 		dsprint(2, "serial: written %s %d\n", err, nw);
@@ -614,7 +614,7 @@ dwrite(Usbfs *fs, Fid *fid, void *buf, int32_t count, int64_t _1)
 	ser = p->s;
 	path = fid->qid.path & ~fs->qid;
 
-	qlock(ser);
+	qlock(&ser->QLock);
 	switch(path){
 	case Qdata:
 		count = altwrite(p, (uint8_t *)buf, count);
@@ -626,7 +626,7 @@ dwrite(Usbfs *fs, Fid *fid, void *buf, int32_t count, int64_t _1)
 		memmove(cmd, buf, count);
 		cmd[count] = 0;
 		if(serialctl(p, cmd) < 0){
-			qunlock(ser);
+			qunlock(&ser->QLock);
 			werrstr(Ebadctl);
 			free(cmd);
 			return -1;
@@ -634,7 +634,7 @@ dwrite(Usbfs *fs, Fid *fid, void *buf, int32_t count, int64_t _1)
 		free(cmd);
 		break;
 	default:
-		qunlock(ser);
+		qunlock(&ser->QLock);
 		werrstr(Eperm);
 		return -1;
 	}
@@ -642,7 +642,7 @@ dwrite(Usbfs *fs, Fid *fid, void *buf, int32_t count, int64_t _1)
 		ser->recover = 0;
 	else
 		serialrecover(ser, p, p->epout, "writing");
-	qunlock(ser);
+	qunlock(&ser->QLock);
 	return count;
 }
 
@@ -658,7 +658,7 @@ openeps(Serialport *p, int epin, int epout, int epintr)
 		return -1;
 	}
 	if(epout == epin){
-		incref(p->epin);
+		incref(&p->epin->Ref);
 		p->epout = p->epin;
 	}else
 		p->epout = openep(ser->dev, epout);
@@ -685,8 +685,8 @@ openeps(Serialport *p, int epin, int epout, int epintr)
 		devctl(p->epintr, "timeout 1000");
 	}
 
-	if(ser->seteps!= nil)
-		ser->seteps(p);
+	if(ser->Serialops.seteps!= nil)
+		ser->Serialops.seteps(p);
 	if(p->epin == p->epout)
 		opendevdata(p->epin, ORDWR);
 	else{
@@ -874,7 +874,7 @@ serialmain(Dev *dev, int argc, char* argv[])
 		p->gotdata = chancreate(sizeof(uint32_t), 0);
 	}
 
-	qlock(ser);
+	qlock(&ser->QLock);
 	serialreset(ser);
 	for(i = 0; i < ser->nifcs; i++){
 		p = &ser->p[i];
@@ -898,12 +898,12 @@ serialmain(Dev *dev, int argc, char* argv[])
 		}
 		fprint(2, "%s...", p->fs.name);
 		p->fs.dev = dev;
-		incref(dev);
+		incref(&dev->Ref);
 		p->fs.aux = p;
 		p->fs.end = serialfsend;
 		usbfsadd(&p->fs);
 	}
 
-	qunlock(ser);
+	qunlock(&ser->QLock);
 	return 0;
 }

+ 3 - 3
sys/src/libusb/serial/silabs.c

@@ -96,7 +96,7 @@ slinit(Serialport *p)
 	slops.getparam(p);
 
 	/* p gets freed by closedev, the process has a reference */
-	incref(ser->dev);
+	incref(&ser->dev->Ref);
 	return 0;
 }
 
@@ -140,10 +140,10 @@ wait4data(Serialport *p, uint8_t *data, int count)
 {
 	int n;
 
-	qunlock(p->s);
+	qunlock(&p->s->QLock);
 	while ((n = read(p->epin->dfd, data, count)) == 0)
 		;
-	qlock(p->s);
+	qlock(&p->s->QLock);
 	return n;
 }