power/devbit3.c (diff list | history)

1990/0324/sys/src/9/power/devbit3.c:11,16 – 1990/06061/sys/src/9/power/devbit3.c:11,17 (short | long)
1990/0324		static struct { QLock;
1990/06061		QLock buflock;
1990/0324		int open; char buf[10*1024]; }bit3;
1990/0324/sys/src/9/power/devbit3.c:140,159 – 1990/06061/sys/src/9/power/devbit3.c:141,170
1990/0324		case 1: if(n > sizeof bit3.buf) error(0, Egreg); docpy = 0; qlock(&bit3); if((((ulong)buf)&(KSEGM|3)) == KSEG0)
1990/06061		if((((ulong)buf)&(KSEGM|3)) == KSEG0){ /* * use supplied buffer, no need to lock for reply */ qlock(&bit3);
1990/0324		bit3send(bp, READ, buf, n); else{
1990/06061		qunlock(&bit3); do n = bp->rcount; while(n == 0); }else{ /* * use bit3 buffer. lock the buffer till the reply */ qlock(&bit3.buflock); qlock(&bit3);
1990/0324		bit3send(bp, READ, bit3.buf, n); docpy = 1; } qunlock(&bit3); do n = bp->rcount; while(n == 0); if(docpy)
1990/06061		qunlock(&bit3); do n = bp->rcount; while(n == 0);
1990/0324		memcpy(buf, bit3.buf, n);
1990/06061		qunlock(&bit3.buflock); }
1990/0324		return n; } error(0, Egreg);
1990/0324/sys/src/9/power/devbit3.c:170,183 – 1990/06061/sys/src/9/power/devbit3.c:181,198
1990/0324		case 1: if(n > sizeof bit3.buf) error(0, Egreg); qlock(&bit3); if((((ulong)buf)&(KSEGM|3)) == KSEG0)
1990/06061		if((((ulong)buf)&(KSEGM|3)) == KSEG0){ qlock(&bit3);
1990/0324		bit3send(bp, WRITE, buf, n); else{
1990/06061		qunlock(&bit3); }else{ qlock(&bit3.buflock); qlock(&bit3);
1990/0324		memcpy(bit3.buf, buf, n); bit3send(bp, WRITE, bit3.buf, n);
1990/06061		qunlock(&bit3); qunlock(&bit3.buflock);
1990/0324		} qunlock(&bit3); return n; } error(0, Egreg);
1990/06061/sys/src/9/power/devbit3.c:90,96 – 1990/0608/sys/src/9/power/devbit3.c:90,96 (short | long)
1990/0324		{ Bit3msg *bp; bp = &((User*)(u->p->upage->pa|KZERO))->bit3;
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->kbit3;
1990/0324		if(c->qid!=1 || omode!=ORDWR) error(0, Eperm); qlock(&bit3);
1990/06061/sys/src/9/power/devbit3.c:135,142 – 1990/0608/sys/src/9/power/devbit3.c:135,140
1990/0324		Bit3msg *bp; int docpy; bp = &((User*)(u->p->upage->pa|KZERO))->bit3; bp->rcount = 0; switch(c->qid){ case 1: if(n > sizeof bit3.buf)
1990/06061/sys/src/9/power/devbit3.c:145,150 – 1990/0608/sys/src/9/power/devbit3.c:143,150
1990/06061		/* * use supplied buffer, no need to lock for reply */
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->kbit3; bp->rcount = 0;
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, READ, buf, n);
1990/06061		qunlock(&bit3);
1990/06061/sys/src/9/power/devbit3.c:155,161 – 1990/0608/sys/src/9/power/devbit3.c:155,164
1990/06061		/* * use bit3 buffer. lock the buffer till the reply */
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->ubit3; bp->rcount = 0;
1990/06061		qlock(&bit3.buflock);
1990/0608
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, READ, bit3.buf, n);
1990/06061		qunlock(&bit3);
1990/06061/sys/src/9/power/devbit3.c:163,168 – 1990/0608/sys/src/9/power/devbit3.c:166,172
1990/06061		n = bp->rcount; while(n == 0);
1990/0324		memcpy(buf, bit3.buf, n);
1990/0608
1990/06061		qunlock(&bit3.buflock); }
1990/0324		return n;
1990/06061/sys/src/9/power/devbit3.c:176,196 – 1990/0608/sys/src/9/power/devbit3.c:180,204
1990/0324		{ Bit3msg *bp; bp = &((User*)(u->p->upage->pa|KZERO))->bit3; switch(c->qid){ case 1: if(n > sizeof bit3.buf) error(0, Egreg);
1990/06061		if((((ulong)buf)&(KSEGM|3)) == KSEG0){
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->kbit3;
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, WRITE, buf, n);
1990/06061		qunlock(&bit3); }else{
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->ubit3;
1990/06061		qlock(&bit3.buflock);
1990/0608
1990/06061		qlock(&bit3);
1990/0324		memcpy(bit3.buf, buf, n); bit3send(bp, WRITE, bit3.buf, n);
1990/0608		do; while(*BIT3ADDR);
1990/06061		qunlock(&bit3);
1990/0608
1990/06061		qunlock(&bit3.buflock);
1990/0324		} return n;
1990/0608/sys/src/9/power/devbit3.c:69,78 – 1990/11211/sys/src/9/power/devbit3.c:69,78 (short | long)
1990/0324		int bit3walk(Chan *c, char *name) { if(c->qid != CHDIR)
1990/11211		if(c->qid.path != CHDIR)
1990/0324		return 0; if(strcmp(name, "bit3") == 0){ c->qid = 1;
1990/11211		c->qid.path = 1;
1990/0324		return 1; } return 0;
1990/0608/sys/src/9/power/devbit3.c:82,88 – 1990/11211/sys/src/9/power/devbit3.c:82,88
1990/0324		bit3stat(Chan *c, char *dp) { print("bit3stat\n"); error(0, Egreg);
1990/11211		error(Egreg);
1990/0324		} Chan*
1990/0608/sys/src/9/power/devbit3.c:91,102 – 1990/11211/sys/src/9/power/devbit3.c:91,102
1990/0324		Bit3msg *bp;
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->kbit3;
1990/0324		if(c->qid!=1 || omode!=ORDWR) error(0, Eperm);
1990/11211		if(c->qid.path!=1 || omode!=ORDWR) error(Eperm);
1990/0324		qlock(&bit3); if(bit3.open){ qunlock(&bit3); error(0, Einuse);
1990/11211		error(Einuse);
1990/0324		} bit3send(bp, RESET, 0, 0); bit3.open = 1;
1990/0608/sys/src/9/power/devbit3.c:110,116 – 1990/11211/sys/src/9/power/devbit3.c:110,116
1990/0324		void bit3create(Chan *c, char *name, int omode, ulong perm) { error(0, Eperm);
1990/11211		error(Eperm);
1990/0324		} void
1990/0608/sys/src/9/power/devbit3.c:135,144 – 1990/11211/sys/src/9/power/devbit3.c:135,144
1990/0324		Bit3msg *bp; int docpy; switch(c->qid){
1990/11211		switch(c->qid.path){
1990/0324		case 1: if(n > sizeof bit3.buf) error(0, Egreg);
1990/11211		error(Egreg);
1990/06061		if((((ulong)buf)&(KSEGM|3)) == KSEG0){ /* * use supplied buffer, no need to lock for reply
1990/0608/sys/src/9/power/devbit3.c:171,177 – 1990/11211/sys/src/9/power/devbit3.c:171,177
1990/06061		}
1990/0324		return n; } error(0, Egreg);
1990/11211		error(Egreg);
1990/0324		return 0; }
1990/0608/sys/src/9/power/devbit3.c:180,189 – 1990/11211/sys/src/9/power/devbit3.c:180,189
1990/0324		{ Bit3msg *bp; switch(c->qid){
1990/11211		switch(c->qid.path){
1990/0324		case 1: if(n > sizeof bit3.buf) error(0, Egreg);
1990/11211		error(Egreg);
1990/06061		if((((ulong)buf)&(KSEGM|3)) == KSEG0){
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->kbit3;
1990/06061		qlock(&bit3);
1990/0608/sys/src/9/power/devbit3.c:203,209 – 1990/11211/sys/src/9/power/devbit3.c:203,209
1990/0324		} return n; } error(0, Egreg);
1990/11211		error(Egreg);
1990/0324		return 0; }
1990/0608/sys/src/9/power/devbit3.c:210,232 – 1990/11211/sys/src/9/power/devbit3.c:210,220
1990/0324		void bit3remove(Chan *c) { error(0, Eperm);
1990/11211		error(Eperm);
1990/0324		} void bit3wstat(Chan *c, char *dp) { error(0, Eperm); }                  void bit3userstr(Error *e, char *buf) { consuserstr(e, buf); }                  void bit3errstr(Error *e, char *buf) { rooterrstr(e, buf);
1990/11211		error(Eperm);
1990/0324		}
1990/11211/sys/src/9/power/devbit3.c:145,150 – 1990/1122/sys/src/9/power/devbit3.c:145,151 (short | long)
1990/06061		*/
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->kbit3; bp->rcount = 0;
1990/1122		qlock(&bit3.buflock); /* BUG */
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, READ, buf, n);
1990/06061		qunlock(&bit3);
1990/11211/sys/src/9/power/devbit3.c:151,156 – 1990/1122/sys/src/9/power/devbit3.c:152,158
1990/06061		do n = bp->rcount; while(n == 0);
1990/1122		qunlock(&bit3.buflock); /* BUG */
1990/06061		}else{ /* * use bit3 buffer. lock the buffer till the reply
1990/11211/sys/src/9/power/devbit3.c:158,164 – 1990/1122/sys/src/9/power/devbit3.c:160,165
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->ubit3; bp->rcount = 0;
1990/06061		qlock(&bit3.buflock);
1990/0608
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, READ, bit3.buf, n);
1990/06061		qunlock(&bit3);
1990/11211/sys/src/9/power/devbit3.c:166,172 – 1990/1122/sys/src/9/power/devbit3.c:167,172
1990/06061		n = bp->rcount; while(n == 0);
1990/0324		memcpy(buf, bit3.buf, n);
1990/0608
1990/06061		qunlock(&bit3.buflock); }
1990/0324		return n;
1990/1122/sys/src/9/power/devbit3.c:145,151 – 1990/1123/sys/src/9/power/devbit3.c:145,150 (short | long)
1990/06061		*/
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->kbit3; bp->rcount = 0;
1990/1122		qlock(&bit3.buflock); /* BUG */
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, READ, buf, n);
1990/06061		qunlock(&bit3);
1990/1122/sys/src/9/power/devbit3.c:152,158 – 1990/1123/sys/src/9/power/devbit3.c:151,156
1990/06061		do n = bp->rcount; while(n == 0);
1990/1122		qunlock(&bit3.buflock); /* BUG */
1990/06061		}else{ /* * use bit3 buffer. lock the buffer till the reply
1990/1123/sys/src/9/power/devbit3.c:164,170 – 1991/0318/sys/src/9/power/devbit3.c:164,170 (short | long)
1990/06061		do n = bp->rcount; while(n == 0);
1990/0324		memcpy(buf, bit3.buf, n);
1991/0318		memmove(buf, bit3.buf, n);
1990/06061		qunlock(&bit3.buflock); }
1990/0324		return n;
1990/1123/sys/src/9/power/devbit3.c:192,198 – 1991/0318/sys/src/9/power/devbit3.c:192,198
1990/06061		qlock(&bit3.buflock);
1990/0608
1990/06061		qlock(&bit3);
1990/0324		memcpy(bit3.buf, buf, n);
1991/0318		memmove(bit3.buf, buf, n);
1990/0324		bit3send(bp, WRITE, bit3.buf, n);
1990/0608		do; while(*BIT3ADDR);
1990/06061		qunlock(&bit3);
1991/0318/sys/src/9/power/devbit3.c:130,136 – 1991/0411/sys/src/9/power/devbit3.c:130,136 (short | long)
1990/0324		*/ long bit3read(Chan *c, void *buf, long n)
1991/0411		bit3read(Chan *c, void *buf, long n, ulong offset)
1990/0324		{ Bit3msg *bp; int docpy;
1991/0318/sys/src/9/power/devbit3.c:174,180 – 1991/0411/sys/src/9/power/devbit3.c:174,180
1990/0324		} long bit3write(Chan *c, void *buf, long n)
1991/0411		bit3write(Chan *c, void *buf, long n, ulong offset)
1990/0324		{ Bit3msg *bp;
1991/0411/sys/src/9/power/devbit3.c:66,71 – 1991/0421/sys/src/9/power/devbit3.c:66,77 (short | long)
1990/0324		return devclone(c, nc); }
1991/0421		Chan* bit3clwalk(Chan *c, char *name) { return devclwalk(c, name); }
1990/0324		int bit3walk(Chan *c, char *name) {
1991/0421/sys/src/9/power/devbit3.c:30,35 – 1991/0425/sys/src/9/power/devbit3.c:30,36 (short | long)
1990/0324		void bit3send(Bit3msg *bp, ulong cmd, void *addr, ulong count) {
1991/0425
1990/0324		do; while(*BIT3ADDR); bp->cmd = cmd; bp->addr = (ulong)addr;
1991/0421/sys/src/9/power/devbit3.c:38,43 – 1991/0425/sys/src/9/power/devbit3.c:39,45
1990/0324		wbflush(); do; while(*BIT3HOLD); *BIT3INTR = 0x20;
1991/0425
1990/0324		} void
1991/0425/sys/src/9/power/devbit3.c:68,79 – 1991/0427/sys/src/9/power/devbit3.c:68,73 (short | long)
1990/0324		return devclone(c, nc); }
1991/0421		Chan* bit3clwalk(Chan *c, char *name) { return devclwalk(c, name); }
1990/0324		int bit3walk(Chan *c, char *name) {
1991/0427/sys/src/9/power/devbit3.c:30,36 – 1991/0430/sys/src/9/power/devbit3.c:30,38 (short | long)
1990/0324		void bit3send(Bit3msg *bp, ulong cmd, void *addr, ulong count) {
1991/0430		int entry;
1991/0425
1991/0430		entry = MACHP(0)->ticks;
1990/0324		do; while(*BIT3ADDR); bp->cmd = cmd; bp->addr = (ulong)addr;
1991/0427/sys/src/9/power/devbit3.c:38,43 – 1991/0430/sys/src/9/power/devbit3.c:40,46
1990/0324		*BIT3ADDR = bp; wbflush(); do; while(*BIT3HOLD);
1991/0430		m->spinlock += entry - MACHP(0)->ticks;
1990/0324		*BIT3INTR = 0x20;
1991/0425
1990/0324		}
1991/0430/sys/src/9/power/devbit3.c:30,38 – 1991/0501/sys/src/9/power/devbit3.c:30,35 (short | long)
1990/0324		void bit3send(Bit3msg *bp, ulong cmd, void *addr, ulong count) {
1991/0430		int entry;
1991/0425
1991/0430		entry = MACHP(0)->ticks;
1990/0324		do; while(*BIT3ADDR); bp->cmd = cmd; bp->addr = (ulong)addr;
1991/0430/sys/src/9/power/devbit3.c:40,46 – 1991/0501/sys/src/9/power/devbit3.c:37,42
1990/0324		*BIT3ADDR = bp; wbflush(); do; while(*BIT3HOLD);
1991/0430		m->spinlock += entry - MACHP(0)->ticks;
1990/0324		*BIT3INTR = 0x20;
1991/0425
1990/0324		}
1991/0430/sys/src/9/power/devbit3.c:139,144 – 1991/0501/sys/src/9/power/devbit3.c:135,141
1990/0324		{ Bit3msg *bp; int docpy;
1991/0501		ulong t0;
1990/0324
1990/11211		switch(c->qid.path){
1990/0324		case 1:
1991/0430/sys/src/9/power/devbit3.c:153,161 – 1991/0501/sys/src/9/power/devbit3.c:150,160
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, READ, buf, n);
1990/06061		qunlock(&bit3);
1991/0501		t0 = MACHP(0)->ticks;
1990/06061		do n = bp->rcount; while(n == 0);
1991/0501		m->spinlock += MACHP(0)->ticks - t0;
1990/06061		}else{ /* * use bit3 buffer. lock the buffer till the reply
1991/0430/sys/src/9/power/devbit3.c:166,174 – 1991/0501/sys/src/9/power/devbit3.c:165,175
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, READ, bit3.buf, n);
1990/06061		qunlock(&bit3);
1991/0501		t0 = MACHP(0)->ticks;
1990/06061		do n = bp->rcount; while(n == 0);
1991/0501		m->spinlock += MACHP(0)->ticks - t0;
1991/0318		memmove(buf, bit3.buf, n);
1990/06061		qunlock(&bit3.buflock); }
1991/0501/sys/src/9/power/devbit3.c:135,141 – 1991/1112/sys/src/9/power/devbit3.c:135,140 (short | long)
1990/0324		{ Bit3msg *bp; int docpy;
1991/0501		ulong t0;
1990/0324
1990/11211		switch(c->qid.path){
1990/0324		case 1:
1991/0501/sys/src/9/power/devbit3.c:150,160 – 1991/1112/sys/src/9/power/devbit3.c:149,157
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, READ, buf, n);
1990/06061		qunlock(&bit3);
1991/0501		t0 = MACHP(0)->ticks;
1990/06061		do n = bp->rcount; while(n == 0);
1991/0501		m->spinlock += MACHP(0)->ticks - t0;
1990/06061		}else{ /* * use bit3 buffer. lock the buffer till the reply
1991/0501/sys/src/9/power/devbit3.c:165,175 – 1991/1112/sys/src/9/power/devbit3.c:162,170
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, READ, bit3.buf, n);
1990/06061		qunlock(&bit3);
1991/0501		t0 = MACHP(0)->ticks;
1990/06061		do n = bp->rcount; while(n == 0);
1991/0501		m->spinlock += MACHP(0)->ticks - t0;
1991/0318		memmove(buf, bit3.buf, n);
1990/06061		qunlock(&bit3.buflock); }
1991/1112/sys/src/9/power/devbit3.c:82,87 – 1991/1209/sys/src/9/power/devbit3.c:82,88 (short | long)
1990/0324		void bit3stat(Chan *c, char *dp) {
1991/1209		USED(c, dp);
1990/0324		print("bit3stat\n");
1990/11211		error(Egreg);
1990/0324		}
1991/1112/sys/src/9/power/devbit3.c:111,116 – 1991/1209/sys/src/9/power/devbit3.c:112,118
1990/0324		void bit3create(Chan *c, char *name, int omode, ulong perm) {
1991/1209		USED(c, name, omode, perm);
1990/11211		error(Eperm);
1990/0324		}
1991/1112/sys/src/9/power/devbit3.c:117,122 – 1991/1209/sys/src/9/power/devbit3.c:119,125
1990/0324		void bit3close(Chan *c) {
1991/1209		USED(c);
1990/0324		qlock(&bit3); bit3.open = 0; qunlock(&bit3);
1991/1112/sys/src/9/power/devbit3.c:135,140 – 1991/1209/sys/src/9/power/devbit3.c:138,144
1990/0324		{ Bit3msg *bp; int docpy;
1991/1209		long i;
1990/0324
1990/11211		switch(c->qid.path){
1990/0324		case 1:
1991/1112/sys/src/9/power/devbit3.c:149,157 – 1991/1209/sys/src/9/power/devbit3.c:153,171
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, READ, buf, n);
1990/06061		qunlock(&bit3); do
1991/1209		for(i=0; i<10*1000*1000; i++){
1990/06061		n = bp->rcount; while(n == 0);
1991/1209		if(n != 0) return n; if(i > 5*1000*1000){ u->p->psstate = "Bit3wait"; while(waserror()) ; tsleep(&u->p->sleep, return0, 0, 1000); poperror(); } } pexit("Suicide", 0);
1990/06061		}else{ /* * use bit3 buffer. lock the buffer till the reply
1991/1112/sys/src/9/power/devbit3.c:162,174 – 1991/1209/sys/src/9/power/devbit3.c:176,199
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, READ, bit3.buf, n);
1990/06061		qunlock(&bit3); do
1991/1209		for(i=0; i<10*1000*1000; i++){
1990/06061		n = bp->rcount; while(n == 0);
1991/0318		memmove(buf, bit3.buf, n);
1991/1209		if(n != 0){ memmove(buf, bit3.buf, n); qunlock(&bit3.buflock); return n; } if(i > 5*1000*1000){ u->p->psstate = "Bit3wait"; while(waserror()) ; tsleep(&u->p->sleep, return0, 0, 1000); poperror(); } }
1990/06061		qunlock(&bit3.buflock);
1991/1209		pexit("Suicide", 0);
1990/06061		}
1990/0324		return n; }
1990/11211		error(Egreg);
1990/0324		return 0;
1991/1112/sys/src/9/power/devbit3.c:191,203 – 1991/1209/sys/src/9/power/devbit3.c:216,226
1990/06061		}else{
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->ubit3;
1990/06061		qlock(&bit3.buflock);
1990/0608
1990/06061		qlock(&bit3);
1991/0318		memmove(bit3.buf, buf, n);
1990/0324		bit3send(bp, WRITE, bit3.buf, n);
1990/0608		do; while(*BIT3ADDR);
1990/06061		qunlock(&bit3);
1990/0608
1990/06061		qunlock(&bit3.buflock);
1990/0324		} return n;
1991/1112/sys/src/9/power/devbit3.c:209,214 – 1991/1209/sys/src/9/power/devbit3.c:232,238
1990/0324		void bit3remove(Chan *c) {
1991/1209		USED(c);
1990/11211		error(Eperm);
1990/0324		}
1991/1112/sys/src/9/power/devbit3.c:215,219 – 1991/1209/sys/src/9/power/devbit3.c:239,244
1990/0324		void bit3wstat(Chan *c, char *dp) {
1991/1209		USED(c, dp);
1990/11211		error(Eperm);
1990/0324		}
1991/1209/sys/src/9/power/devbit3.c:3,9 – 1992/0111/sys/src/9/power/devbit3.c:3,9 (short | long)
1990/0324		#include "mem.h" #include "dat.h" #include "fns.h" #include "errno.h"
1992/0111		#include "../port/error.h"
1990/0324		#include "devtab.h" #include "io.h"
1992/0111/sys/src/9/power/devbit3.c:1,244 – 1992/0306/sys/src/9/power/devbit3.c:0 (short | long)
Deleted. rsc Mon Mar 7 10:32:50 2005
1990/0324		#include "u.h" #include "lib.h" #include "mem.h" #include "dat.h" #include "fns.h"
1992/0111		#include "../port/error.h"
1990/0324		#include "devtab.h"                  #include "io.h"                  static struct { QLock;
1990/06061		QLock buflock;
1990/0324		int open; char buf[10*1024]; }bit3;                  #define BIT3ADDR ((Bit3msg**)(KZERO+0x7C)) #define BIT3HOLD ((ulong*)(KZERO+0x78)) #define BIT3INTR ((char*)(UNCACHED|0x17c12001))                  enum { RESET, READ, WRITE, };                  void bit3send(Bit3msg *bp, ulong cmd, void *addr, ulong count) { do; while(*BIT3ADDR); bp->cmd = cmd; bp->addr = (ulong)addr; bp->count = count; *BIT3ADDR = bp; wbflush(); do; while(*BIT3HOLD); *BIT3INTR = 0x20;
1991/0425
1990/0324		}                  void bit3reset(void) { *BIT3HOLD = 0; *BIT3ADDR = 0; qlock(&bit3); qunlock(&bit3); }                  void bit3init(void) { }                  Chan* bit3attach(char *spec) { return devattach('3', spec); }                  Chan* bit3clone(Chan *c, Chan *nc) { return devclone(c, nc); }                  int bit3walk(Chan *c, char *name) {
1990/11211		if(c->qid.path != CHDIR)
1990/0324		return 0; if(strcmp(name, "bit3") == 0){
1990/11211		c->qid.path = 1;
1990/0324		return 1; } return 0; }                  void bit3stat(Chan *c, char *dp) {
1991/1209		USED(c, dp);
1990/0324		print("bit3stat\n");
1990/11211		error(Egreg);
1990/0324		}                  Chan* bit3open(Chan *c, int omode) { Bit3msg *bp;
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->kbit3;
1990/11211		if(c->qid.path!=1 || omode!=ORDWR) error(Eperm);
1990/0324		qlock(&bit3); if(bit3.open){ qunlock(&bit3);
1990/11211		error(Einuse);
1990/0324		} bit3send(bp, RESET, 0, 0); bit3.open = 1; qunlock(&bit3); c->mode = openmode(omode); c->flag |= COPEN; c->offset = 0; return c; }                  void bit3create(Chan *c, char *name, int omode, ulong perm) {
1991/1209		USED(c, name, omode, perm);
1990/11211		error(Eperm);
1990/0324		}                  void bit3close(Chan *c) {
1991/1209		USED(c);
1990/0324		qlock(&bit3); bit3.open = 0; qunlock(&bit3); }                  /* * Read and write use physical addresses if they can, which they usually can. * Most I/O is from devmnt, which has local buffers. Therefore just check * that buf is in KSEG0 and is at an even address. The only killer is that * DMA counts from the bit3 device are mod 256, so devmnt must use oversize * buffers. */                  long
1991/0411		bit3read(Chan *c, void *buf, long n, ulong offset)
1990/0324		{ Bit3msg *bp; int docpy;
1991/1209		long i;
1990/0324
1990/11211		switch(c->qid.path){
1990/0324		case 1: if(n > sizeof bit3.buf)
1990/11211		error(Egreg);
1990/06061		if((((ulong)buf)&(KSEGM|3)) == KSEG0){ /* * use supplied buffer, no need to lock for reply */
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->kbit3; bp->rcount = 0;
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, READ, buf, n);
1990/06061		qunlock(&bit3);
1991/1209		for(i=0; i<10*1000*1000; i++){
1990/06061		n = bp->rcount;
1991/1209		if(n != 0) return n; if(i > 5*1000*1000){ u->p->psstate = "Bit3wait"; while(waserror()) ; tsleep(&u->p->sleep, return0, 0, 1000); poperror(); } } pexit("Suicide", 0);
1990/06061		}else{ /* * use bit3 buffer. lock the buffer till the reply */
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->ubit3; bp->rcount = 0;
1990/06061		qlock(&bit3.buflock); qlock(&bit3);
1990/0324		bit3send(bp, READ, bit3.buf, n);
1990/06061		qunlock(&bit3);
1991/1209		for(i=0; i<10*1000*1000; i++){
1990/06061		n = bp->rcount;
1991/1209		if(n != 0){ memmove(buf, bit3.buf, n); qunlock(&bit3.buflock); return n; } if(i > 5*1000*1000){ u->p->psstate = "Bit3wait"; while(waserror()) ; tsleep(&u->p->sleep, return0, 0, 1000); poperror(); } }
1990/06061		qunlock(&bit3.buflock);
1991/1209		pexit("Suicide", 0);
1990/06061		}
1990/0324		}
1990/11211		error(Egreg);
1990/0324		return 0; }                  long
1991/0411		bit3write(Chan *c, void *buf, long n, ulong offset)
1990/0324		{ Bit3msg *bp;
1990/11211		switch(c->qid.path){
1990/0324		case 1: if(n > sizeof bit3.buf)
1990/11211		error(Egreg);
1990/06061		if((((ulong)buf)&(KSEGM|3)) == KSEG0){
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->kbit3;
1990/06061		qlock(&bit3);
1990/0324		bit3send(bp, WRITE, buf, n);
1990/06061		qunlock(&bit3); }else{
1990/0608		bp = &((User*)(u->p->upage->pa|KZERO))->ubit3;
1990/06061		qlock(&bit3.buflock); qlock(&bit3);
1991/0318		memmove(bit3.buf, buf, n);
1990/0324		bit3send(bp, WRITE, bit3.buf, n);
1990/0608		do; while(*BIT3ADDR);
1990/06061		qunlock(&bit3); qunlock(&bit3.buflock);
1990/0324		} return n; }
1990/11211		error(Egreg);
1990/0324		return 0; }                  void bit3remove(Chan *c) {
1991/1209		USED(c);
1990/11211		error(Eperm);
1990/0324		}                  void bit3wstat(Chan *c, char *dp) {
1991/1209		USED(c, dp);
1990/11211		error(Eperm);
1990/0324		}