plan 9 kernel history: overview | file list | diff list

1991/0303/power/devhotrod.c (diff list | history)

1991/0302/sys/src/9/power/devhotrod.c:10,151991/0303/sys/src/9/power/devhotrod.c:10,22 (short | long | prev | next)
1990/1013    
#include	"io.h" 
1991/0215    
#include	"hrod.h" 
1990/1013    
 
1991/0303    
void	mem(Hot*, ulong*, ulong); 
 
/* 
 * If set, causes data transfers to have checksums 
 */ 
#define	ENABCKSUM	1 
 
1990/1013    
typedef struct Hotrod	Hotrod; 
1991/0209    
typedef struct HotQ	HotQ; 
1990/1013    
 
1991/0302/sys/src/9/power/devhotrod.c:55,621991/0303/sys/src/9/power/devhotrod.c:62,69
1991/0209    
enum{ 
	RESET=	0,	/* params: Q address, length of queue */ 
	REBOOT=	1,	/* params: none */ 
1991/0212    
	READ=	2,	/* params: buffer, count, returned count */ 
	WRITE=	3,	/* params: buffer, count */ 
1991/0303    
	READ=	2,	/* params: buffer, count, sum, returned count */ 
	WRITE=	3,	/* params: buffer, count, sum */ 
1991/0214    
	TEST=	7,	/* params: none */ 
1991/0209    
}; 
 
1991/0302/sys/src/9/power/devhotrod.c:192,1981991/0303/sys/src/9/power/devhotrod.c:199,209
1991/0227    
		mp->param[1] = NTESTBUF; 
1991/0219    
		hotsend(hp, &((User*)(u->p->upage->pa|KZERO))->khot); 
		delay(100); 
		print("tested\n"); 
1991/0303    
		print("testing addr %lux size %ld\n", mp->param[0], mp->param[1]); 
		for(;;){ 
			print("-"); 
			mem(hp->addr, &hp->addr->ram[(mp->param[0]-0x40000)/sizeof(ulong)], mp->param[1]); 
		} 
1991/0302    
#endif 
1990/1018    
	} 
1990/1013    
	c->mode = openmode(omode); 
1991/0302/sys/src/9/power/devhotrod.c:220,2251991/0303/sys/src/9/power/devhotrod.c:231,250
1991/0209    
	} 
1990/1013    
} 
 
1991/0303    
ulong 
hotsum(ulong *p, int n, ulong doit) 
{ 
	ulong sum; 
 
	if(!doit) 
		return 0; 
	sum = 0; 
	n = (n+sizeof(ulong)-1)/sizeof(ulong); 
	while(--n >= 0) 
		sum += *p++; 
	return sum; 
} 
 
1990/1013    
/* 
1991/0212    
 * 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 
1991/0302/sys/src/9/power/devhotrod.c:231,2371991/0303/sys/src/9/power/devhotrod.c:256,262
1990/1013    
{ 
	Hotrod *hp; 
1991/0212    
	Hotmsg *mp; 
1991/0215    
	ulong l; 
1991/0303    
	ulong l, m; 
1990/1013    
 
	hp = &hotrod[c->dev]; 
1991/0212    
	switch(c->qid.path){ 
1991/0302/sys/src/9/power/devhotrod.c:245,2511991/0303/sys/src/9/power/devhotrod.c:270,277
1991/0212    
			 *  use supplied buffer, no need to lock for reply 
			 */ 
			mp = &u->khot; 
			mp->param[2] = 0;	/* reply count */ 
1991/0303    
			mp->param[2] = 0;	/* checksum */ 
			mp->param[3] = 0;	/* reply count */ 
1991/0212    
			qlock(hp); 
			mp->cmd = READ; 
			mp->param[0] = MP2VME(buf); 
1991/0302/sys/src/9/power/devhotrod.c:254,2711991/0303/sys/src/9/power/devhotrod.c:280,303
1991/0212    
			qunlock(hp); 
1991/0220    
			l = 100*1000*1000; 
1991/0212    
			do 
				n = mp->param[2]; 
1991/0215    
			while(n==0 && --l>0); 
			if(n == 0){ 
				print("devhotrod: give up\n"); 
1991/0303    
				m = mp->param[3]; 
			while(m==0 && --l>0); 
			if(m==0 || m>n){ 
				print("devhotrod: count %ld %ld\n", m, n); 
1991/0215    
				error(Egreg); 
			} 
1991/0303    
			if(mp->param[2] != hotsum(buf, m, mp->param[2])){ 
				print("hotrod cksum err is %lux sb %lux\n", 
					hotsum(buf, n, 1), mp->param[2]); 
				error(Eio); 
			} 
1991/0212    
		}else{ 
			/* 
1991/0215    
			 *  use hotrod buffer.  lock the buffer until the reply 
1991/0212    
			 */ 
			mp = &u->uhot; 
			mp->param[2] = 0;	/* reply count */ 
1991/0303    
			mp->param[2] = 0;	/* checksum */ 
			mp->param[3] = 0;	/* reply count */ 
1991/0212    
			qlock(&hp->buflock); 
			qlock(hp); 
			mp->cmd = READ; 
1991/0302/sys/src/9/power/devhotrod.c:275,2901991/0303/sys/src/9/power/devhotrod.c:307,329
1991/0212    
			qunlock(hp); 
1991/0215    
			l = 100*1000*1000; 
1991/0212    
			do 
				n = mp->param[2]; 
1991/0215    
			while(n==0 && --l>0); 
1991/0212    
			memcpy(buf, hp->buf, n); 
			qunlock(&hp->buflock); 
1991/0215    
			if(n == 0){ 
				print("devhotrod: give up\n"); 
1991/0303    
				m = mp->param[3]; 
			while(m==0 && --l>0); 
			if(m==0 || m>n){ 
				print("devhotrod: count %ld %ld\n", m, n); 
				qunlock(&hp->buflock); 
1991/0215    
				error(Egreg); 
			} 
1991/0303    
			if(mp->param[2] != hotsum((ulong*)hp->buf, m, mp->param[2])){ 
				print("hotrod cksum err is %lux sb %lux\n", 
					hotsum((ulong*)hp->buf, n, 1), mp->param[2]); 
				qunlock(&hp->buflock); 
				error(Eio); 
			} 
			memcpy(buf, hp->buf, m); 
			qunlock(&hp->buflock); 
1991/0212    
		} 
		return n; 
1991/0303    
		return m; 
1990/1020    
	} 
1991/0220    
	print("hotrod read unk\n"); 
1991/0212    
	error(Egreg); 
1991/0302/sys/src/9/power/devhotrod.c:316,3211991/0303/sys/src/9/power/devhotrod.c:355,361
1991/0212    
			mp->cmd = WRITE; 
			mp->param[0] = MP2VME(buf); 
			mp->param[1] = n; 
1991/0303    
			mp->param[2] = hotsum(buf, n, ENABCKSUM); 
1991/0212    
			hotsend(hp, &((User*)(u->p->upage->pa|KZERO))->khot); 
			qunlock(hp); 
		}else{ 
1991/0302/sys/src/9/power/devhotrod.c:329,3341991/0303/sys/src/9/power/devhotrod.c:369,375
1991/0212    
			mp->cmd = WRITE; 
			mp->param[0] = MP2VME(hp->buf); 
			mp->param[1] = n; 
1991/0303    
			mp->param[2] = hotsum((ulong*)hp->buf, n, ENABCKSUM); 
1991/0212    
			hotsend(hp, &((User*)(u->p->upage->pa|KZERO))->uhot); 
			qunlock(hp); 
			qunlock(&hp->buflock); 
1991/0302/sys/src/9/power/devhotrod.c:364,3671991/0303/sys/src/9/power/devhotrod.c:405,498
1990/1013    
		return; 
	} 
1991/0219    
	hp->addr->lcsr3 &= ~INT_VME; 
1991/0303    
} 
 
void 
mem(Hot *hot, ulong *buf, ulong size) 
{ 
	long i, j, k, l; 
	ulong *p, bit, u; 
	int q; 
 
goto part4; 
	/* one bit */ 
	bit = 0; 
	p = buf; 
	for(i=0; i<size; i++,p++) { 
		if(bit == 0) 
			bit = 1; 
		*p = bit; 
		bit <<= 1; 
	} 
	bit = 0; 
	p = buf; 
	for(i=0; i<size; i++,p++) { 
		if(bit == 0) 
			bit = 1; 
		if(*p != bit) { 
			print("A: %lux is %lux sb %lux\n", p, *p, bit); 
			hot->error++; 
			delay(500); 
		} 
		bit <<= 1; 
	} 
	/* all but one bit */ 
	bit = 0; 
	p = buf; 
	for(i=0; i<size; i++,p++) { 
		if(bit == 0) 
			bit = 1; 
		*p = ~bit; 
		bit <<= 1; 
	} 
	bit = 0; 
	p = buf; 
	for(i=0; i<size; i++,p++) { 
		if(bit == 0) 
			bit = 1; 
		if(*p != ~bit) { 
			print("B: %lux is %lux sb %lux\n", p, *p, ~bit); 
			hot->error++; 
			delay(500); 
		} 
		bit <<= 1; 
	} 
	/* rand bit */ 
	bit = 0; 
	p = buf; 
	for(i=0; i<size; i++,p++) { 
		if(bit == 0) 
			bit = 1; 
		*p = bit; 
		bit += PRIME; 
	} 
	bit = 0; 
	p = buf; 
	for(i=0; i<size; i++,p++) { 
		if(bit == 0) 
			bit = 1; 
		if(*p != bit) { 
			print("C: %lux is %lux sb %lux\n", p, *p, bit); 
			hot->error++; 
			delay(500); 
		} 
		bit += PRIME; 
	} 
part4: 
	/* address */ 
	p = buf; 
	for(i=0; i<size; i++,p++) 
		*p = i; 
	for(j=0; j<200; j++) { 
		p = buf; 
		for(i=0; i<size; i++,p++) { 
			u = *p; 
			if(u != i+j) { 
				print("D: %lux is %lux sb %lux (%lux)\n", p, u, i+j, *p); 
			hot->error++; 
				delay(500); 
			} 
			*p = i+j+1; 
		} 
	} 
1990/1013    
} 


source code copyright © 1990-2005 Lucent Technologies; see license
Plan 9 distribution
comments to russ cox (rsc@swtch.com)