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

1992/0321/pc/devrtc.c (diff list | history)

1991/0911/sys/src/9/pc/devrtc.c:36,42 – 1991/1112/sys/src/9/pc/devrtc.c:36,42 (short | long)
1991/0911    
 
#define	NRTC	1 
Dirtab rtcdir[]={ 
	"rtc",		{1, 0},	0,	0600,
1991/1112    
	"rtc",		{1, 0},	0,	0666,
1991/0911    
}; 
 
ulong rtc2sec(Rtc*);
1991/1112/sys/src/9/pc/devrtc.c:6,11 – 1991/1211/sys/src/9/pc/devrtc.c:6,15 (short | long)
1991/0911    
#include	"errno.h" 
#include	"devtab.h"
1991/1211    
/* 
 *  real time clock and non-volatile ram 
 */
1991/0911    
enum { 
	Paddr=		0x70,	/* address port */ 
	Pdata=		0x71,	/* data port */
1991/1211/sys/src/9/pc/devrtc.c:3,9 – 1992/0111/sys/src/9/pc/devrtc.c:3,9 (short | long)
1991/0911    
#include	"mem.h" 
#include	"dat.h" 
#include	"fns.h" 
#include	"errno.h"
1992/0111    
#include	"../port/error.h"
1991/0911    
#include	"devtab.h"
1991/1211    
/*
1992/0111/sys/src/9/pc/devrtc.c:1,5 – 1992/0321/sys/src/9/pc/devrtc.c:1,5 (short | long)
1991/0911    
#include	"u.h" 
#include	"lib.h"
1992/0321    
#include	"../port/lib.h"
1991/0911    
#include	"mem.h" 
#include	"dat.h" 
#include	"fns.h"
1992/0321/sys/src/9/pc/devrtc.c:90,95 – 1992/0711/sys/src/9/pc/devrtc.c:90,96 (short | long)
1991/0911    
void	  
rtccreate(Chan *c, char *name, int omode, ulong perm) 
{
1992/0711    
	USED(c, name, omode, perm);
1991/0911    
	error(Eperm); 
}
1992/0321/sys/src/9/pc/devrtc.c:96,101 – 1992/0711/sys/src/9/pc/devrtc.c:97,103
1991/0911    
void	  
rtcclose(Chan *c) 
{
1992/0711    
	USED(c);
1991/0911    
} 
 
#define GETBCD(o) ((bcdclock[o]&0xf) + 10*(bcdclock[o]>>4))
1992/0321/sys/src/9/pc/devrtc.c:103,112 – 1992/0711/sys/src/9/pc/devrtc.c:105,111
1991/0911    
long	  
rtctime(void) 
{ 
	int i,j; 
	uchar ch; 
	uchar bcdclock[Nbcd]; 
	char atime[64]; 
	Rtc rtc; 
 
	outb(Paddr, Status);
1992/0321/sys/src/9/pc/devrtc.c:166,177 – 1992/0711/sys/src/9/pc/devrtc.c:165,174
1991/0911    
{ 
	Rtc rtc; 
	ulong secs; 
	int i,j; 
	uchar ch; 
	uchar bcdclock[Nbcd]; 
	uchar *nv; 
	char *cp, *ep;
1992/0711    
	USED(c);
1991/0911    
	if(offset!=0) 
		error(Ebadarg);
1992/0321/sys/src/9/pc/devrtc.c:216,221 – 1992/0711/sys/src/9/pc/devrtc.c:213,219
1991/0911    
void	  
rtcremove(Chan *c) 
{
1992/0711    
	USED(c);
1991/0911    
	error(Eperm); 
}
1992/0321/sys/src/9/pc/devrtc.c:222,227 – 1992/0711/sys/src/9/pc/devrtc.c:220,226
1991/0911    
void	  
rtcwstat(Chan *c, char *dp) 
{
1992/0711    
	USED(c, dp);
1991/0911    
	error(Eperm); 
}
1992/0711/sys/src/9/pc/devrtc.c:84,89 – 1992/0819/sys/src/9/pc/devrtc.c:84,99 (short | long)
1991/0911    
Chan* 
rtcopen(Chan *c, int omode) 
{
1992/0819    
	omode = openmode(omode); 
	switch(c->qid.path){ 
	case Qrtc: 
		if(omode == OREAD) 
			break; 
		/* fall through */ 
	case Qnvram: 
		if(strcmp(u->p->user, eve)!=0 || !cpuserver) 
			error(Eperm); 
	}
1991/0911    
	return devopen(c, omode, rtcdir, NRTC, devgen); 
}
1992/0819/sys/src/9/pc/devrtc.c:38,46 – 1992/0820/sys/src/9/pc/devrtc.c:38,51 (short | long)
1991/0911    
 
QLock rtclock;	/* mutex on clock operations */
1992/0820    
enum{ 
	Qrtc = 1, 
	Qnvram, 
};
1991/0911    
#define	NRTC	1 
Dirtab rtcdir[]={
1991/1112    
	"rtc",		{1, 0},	0,	0666,
1992/0820    
	"rtc",		{Qrtc, 0},	0,	0666,
1991/0911    
}; 
 
ulong rtc2sec(Rtc*);
1992/0820/sys/src/9/pc/devrtc.c:92,100 – 1992/0826/sys/src/9/pc/devrtc.c:92,100 (short | long)
1992/0819    
	omode = openmode(omode); 
	switch(c->qid.path){ 
	case Qrtc: 
		if(omode == OREAD) 
			break; 
		/* fall through */
1992/0826    
		if(omode != OREAD && strcmp(u->p->user, eve)!=0) 
			error(Eperm); 
		break;
1992/0819    
	case Qnvram: 
		if(strcmp(u->p->user, eve)!=0 || !cpuserver) 
			error(Eperm);
1992/0826/sys/src/9/pc/devrtc.c:92,98 – 1992/0902/sys/src/9/pc/devrtc.c:92,98 (short | long)
1992/0819    
	omode = openmode(omode); 
	switch(c->qid.path){ 
	case Qrtc:
1992/0826    
		if(omode != OREAD && strcmp(u->p->user, eve)!=0)
1992/0902    
		if(strcmp(u->p->user, eve)!=0 && omode!=OREAD)
1992/0826    
			error(Eperm); 
		break;
1992/0819    
	case Qnvram:
1992/0902/sys/src/9/pc/devrtc.c:353,355 – 1992/1006/sys/src/9/pc/devrtc.c:353,362 (short | long)
1991/0911    
 
	return; 
}
1992/1006    
 
uchar 
nvramread(int offset) 
{ 
	outb(Paddr, offset); 
	return inb(Pdata); 
}
1992/1006/sys/src/9/pc/devrtc.c:60,65 – 1992/1014/sys/src/9/pc/devrtc.c:60,66 (short | long)
1991/0911    
void 
rtcinit(void) 
{
1992/1014    
	print("nvrm(0x2b) == 0x%lux\n", nvramread(0x2b));
1991/0911    
} 
 
Chan*
1992/1014/sys/src/9/pc/devrtc.c:60,66 – 1992/1015/sys/src/9/pc/devrtc.c:60,65 (short | long)
1991/0911    
void 
rtcinit(void) 
{
1992/1014    
	print("nvrm(0x2b) == 0x%lux\n", nvramread(0x2b));
1991/0911    
} 
 
Chan*
1992/1015/sys/src/9/pc/devrtc.c:122,131 – 1992/1208/sys/src/9/pc/devrtc.c:122,134 (short | long)
1991/0911    
{ 
	uchar bcdclock[Nbcd]; 
	Rtc rtc;
1992/1208    
	int i;
1991/0911    
 
	outb(Paddr, Status); 
	while(inb(Pdata) & 1) 
		;
1992/1208    
	for(i = 0; i < 10000; i++){ 
		outb(Paddr, Status); 
		if((inb(Pdata) & 1) == 0) 
			break; 
	}
1991/0911    
	outb(Paddr, Seconds);	bcdclock[0] = inb(Pdata); 
	outb(Paddr, Minutes);	bcdclock[1] = inb(Pdata); 
	outb(Paddr, Hours);	bcdclock[2] = inb(Pdata);
1992/1208/sys/src/9/pc/devrtc.c:22,27 – 1993/0319/sys/src/9/pc/devrtc.c:22,30 (short | long)
1991/0911    
	Year=		0x09, 
	Status=		0x0A,
1993/0319    
	Nvoff=		128,	/* where usable nvram lives */ 
	Nvsize=		128,
1991/0911    
	Nbcd=		6, 
};
1992/1208/sys/src/9/pc/devrtc.c:43,50 – 1993/0319/sys/src/9/pc/devrtc.c:46,54
1992/0820    
	Qnvram, 
};
1991/0911    
#define	NRTC	1
1993/0319    
#define	NRTC	2
1991/0911    
Dirtab rtcdir[]={
1993/0319    
	"nvram",	{Qnvram, 0},	Nvsize,	0666,
1992/0820    
	"rtc",		{Qrtc, 0},	0,	0666,
1991/0911    
};
1992/1208/sys/src/9/pc/devrtc.c:96,102 – 1993/0319/sys/src/9/pc/devrtc.c:100,106
1992/0826    
			error(Eperm); 
		break;
1992/0819    
	case Qnvram: 
		if(strcmp(u->p->user, eve)!=0 || !cpuserver)
1993/0319    
		if(strcmp(u->p->user, eve)!=0)
1992/0819    
			error(Eperm); 
	}
1991/0911    
	return devopen(c, omode, rtcdir, NRTC, devgen);
1992/1208/sys/src/9/pc/devrtc.c:160,179 – 1993/0319/sys/src/9/pc/devrtc.c:164,204
1991/0911    
rtcread(Chan *c, void *buf, long n, ulong offset) 
{ 
	ulong t, ot;
1993/0319    
	char *a;
1991/0911    
 
	if(c->qid.path & CHDIR) 
		return devdirread(c, buf, n, rtcdir, NRTC, devgen); 
 
	qlock(&rtclock); 
	t = rtctime(); 
	do{ 
		ot = t; 
		t = rtctime();	/* make sure there's no skew */ 
	}while(t != ot); 
	qunlock(&rtclock); 
	n = readnum(offset, buf, n, t, 12); 
	return n; 
                 
1993/0319    
	switch(c->qid.path){ 
	case Qrtc: 
		qlock(&rtclock); 
		t = rtctime(); 
		do{ 
			ot = t; 
			t = rtctime();	/* make sure there's no skew */ 
		}while(t != ot); 
		qunlock(&rtclock); 
		n = readnum(offset, buf, n, t, 12); 
		return n; 
	case Qnvram: 
		a = buf; 
		if(waserror()){ 
			qunlock(&rtclock); 
			nexterror(); 
		} 
		qlock(&rtclock); 
		for(t = offset; t < offset + n; t++){ 
			if(t >= Nvsize) 
				break; 
			outb(Paddr, Nvoff+t); 
			*a++ = inb(Pdata); 
		} 
		qunlock(&rtclock); 
		poperror(); 
		return t - offset; 
	} 
	error(Ebadarg); 
	return 0;
1991/0911    
} 
 
#define PUTBCD(n,o) bcdclock[o] = (n % 10) | (((n / 10) % 10)<<4)
1992/1208/sys/src/9/pc/devrtc.c:181,186 – 1993/0319/sys/src/9/pc/devrtc.c:206,213
1991/0911    
long	  
rtcwrite(Chan *c, void *buf, long n, ulong offset) 
{
1993/0319    
	int t; 
	char *a;
1991/0911    
	Rtc rtc; 
	ulong secs; 
	uchar bcdclock[Nbcd];
1992/1208/sys/src/9/pc/devrtc.c:190,231 – 1993/0319/sys/src/9/pc/devrtc.c:217,279
1991/0911    
	if(offset!=0) 
		error(Ebadarg); 
 
	/* 
	 *  read the time 
	 */ 
	cp = ep = buf; 
	ep += n; 
	while(cp < ep){ 
		if(*cp>='0' && *cp<='9') 
			break; 
		cp++; 
	} 
	secs = strtoul(cp, 0, 0); 
 
	/* 
	 *  convert to bcd 
	 */ 
	sec2rtc(secs, &rtc); 
	PUTBCD(rtc.sec, 0); 
	PUTBCD(rtc.min, 1); 
	PUTBCD(rtc.hour, 2); 
	PUTBCD(rtc.mday, 3); 
	PUTBCD(rtc.mon, 4); 
	PUTBCD(rtc.year, 5);
1993/0319    
	switch(c->qid.path){ 
	case Qrtc: 
		/* 
		 *  read the time 
		 */ 
		cp = ep = buf; 
		ep += n; 
		while(cp < ep){ 
			if(*cp>='0' && *cp<='9') 
				break; 
			cp++; 
		} 
		secs = strtoul(cp, 0, 0); 
	 
		/* 
		 *  convert to bcd 
		 */ 
		sec2rtc(secs, &rtc); 
		PUTBCD(rtc.sec, 0); 
		PUTBCD(rtc.min, 1); 
		PUTBCD(rtc.hour, 2); 
		PUTBCD(rtc.mday, 3); 
		PUTBCD(rtc.mon, 4); 
		PUTBCD(rtc.year, 5);
1991/0911    
 
	/* 
	 *  write the clock 
	 */ 
	qlock(&rtclock); 
	outb(Paddr, Seconds);	outb(Pdata, bcdclock[0]); 
	outb(Paddr, Minutes);	outb(Pdata, bcdclock[1]); 
	outb(Paddr, Hours);	outb(Pdata, bcdclock[2]); 
	outb(Paddr, Mday);	outb(Pdata, bcdclock[3]); 
	outb(Paddr, Month);	outb(Pdata, bcdclock[4]); 
	outb(Paddr, Year);	outb(Pdata, bcdclock[5]); 
	qunlock(&rtclock); 
                 
	return n;
1993/0319    
		/* 
		 *  write the clock 
		 */ 
		qlock(&rtclock); 
		outb(Paddr, Seconds);	outb(Pdata, bcdclock[0]); 
		outb(Paddr, Minutes);	outb(Pdata, bcdclock[1]); 
		outb(Paddr, Hours);	outb(Pdata, bcdclock[2]); 
		outb(Paddr, Mday);	outb(Pdata, bcdclock[3]); 
		outb(Paddr, Month);	outb(Pdata, bcdclock[4]); 
		outb(Paddr, Year);	outb(Pdata, bcdclock[5]); 
		qunlock(&rtclock); 
		return n; 
	case Qnvram: 
		a = buf; 
		if(waserror()){ 
			qunlock(&rtclock); 
			nexterror(); 
		} 
		qlock(&rtclock); 
		for(t = offset; t < offset + n; t++){ 
			if(t >= Nvsize) 
				break; 
			outb(Paddr, Nvoff+t); 
			outb(Pdata, *a++); 
		} 
		qunlock(&rtclock); 
		poperror(); 
		return t - offset; 
	} 
	error(Ebadarg); 
	return 0;
1991/0911    
} 
 
void
1993/0319/sys/src/9/pc/devrtc.c:23,29 – 1993/0915/sys/src/9/pc/devrtc.c:23,29 (short | long)
1991/0911    
	Status=		0x0A,
1993/0319    
	Nvoff=		128,	/* where usable nvram lives */ 
	Nvsize=		128,
1993/0915    
	Nvsize=		256,
1993/0319    
1991/0911    
	Nbcd=		6, 
};
1993/0319/sys/src/9/pc/devrtc.c:48,55 – 1993/0915/sys/src/9/pc/devrtc.c:48,55
1992/0820    
1993/0319    
#define	NRTC	2
1991/0911    
Dirtab rtcdir[]={
1993/0319    
	"nvram",	{Qnvram, 0},	Nvsize,	0666,
1992/0820    
	"rtc",		{Qrtc, 0},	0,	0666,
1993/0915    
	"nvram",	{Qnvram, 0},	Nvsize,	0664, 
	"rtc",		{Qrtc, 0},	0,	0664,
1991/0911    
}; 
 
ulong rtc2sec(Rtc*);
1993/0319/sys/src/9/pc/devrtc.c:96,106 – 1993/0915/sys/src/9/pc/devrtc.c:96,106
1992/0819    
	omode = openmode(omode); 
	switch(c->qid.path){ 
	case Qrtc:
1992/0902    
		if(strcmp(u->p->user, eve)!=0 && omode!=OREAD)
1993/0915    
		if(strcmp(up->user, eve)!=0 && omode!=OREAD)
1992/0826    
			error(Eperm); 
		break;
1992/0819    
	case Qnvram:
1993/0319    
		if(strcmp(u->p->user, eve)!=0)
1993/0915    
		if(strcmp(up->user, eve)!=0)
1992/0819    
			error(Eperm); 
	}
1991/0911    
	return devopen(c, omode, rtcdir, NRTC, devgen);
1993/0915/sys/src/9/pc/devrtc.c:201,206 – 1995/0108/sys/src/9/pc/devrtc.c:201,212 (short | long)
1993/0319    
	return 0;
1991/0911    
}
1995/0108    
Block* 
rtcbread(Chan *c, long n, ulong offset) 
{ 
	return devbread(c, n, offset); 
}
1991/0911    
#define PUTBCD(n,o) bcdclock[o] = (n % 10) | (((n / 10) % 10)<<4) 
 
long
1993/0915/sys/src/9/pc/devrtc.c:274,279 – 1995/0108/sys/src/9/pc/devrtc.c:280,291
1993/0319    
	} 
	error(Ebadarg); 
	return 0;
1995/0108    
} 
 
long 
rtcbwrite(Chan *c, Block *bp, ulong offset) 
{ 
	return devbwrite(c, bp, offset);
1991/0911    
} 
 
void
1995/0108/sys/src/9/pc/devrtc.c:107,115 – 1995/0726/sys/src/9/pc/devrtc.c:107,114 (short | long)
1991/0911    
} 
 
void	  
rtccreate(Chan *c, char *name, int omode, ulong perm)
1995/0726    
rtccreate(Chan*, char*, int, ulong)
1991/0911    
{
1992/0711    
	USED(c, name, omode, perm);
1991/0911    
	error(Eperm); 
}
1995/0726/sys/src/9/pc/devrtc.c:113,121 – 1995/0822/sys/src/9/pc/devrtc.c:113,120 (short | long)
1991/0911    
} 
 
void	  
rtcclose(Chan *c)
1995/0822    
rtcclose(Chan*)
1991/0911    
{
1992/0711    
	USED(c);
1991/0911    
} 
 
#define GETBCD(o) ((bcdclock[o]&0xf) + 10*(bcdclock[o]>>4))
1995/0726/sys/src/9/pc/devrtc.c:218,224 – 1995/0822/sys/src/9/pc/devrtc.c:217,222
1991/0911    
	uchar bcdclock[Nbcd]; 
	char *cp, *ep;
1992/0711    
	USED(c);
1991/0911    
	if(offset!=0) 
		error(Ebadarg);
1995/0726/sys/src/9/pc/devrtc.c:288,303 – 1995/0822/sys/src/9/pc/devrtc.c:286,299
1991/0911    
} 
 
void	  
rtcremove(Chan *c)
1995/0822    
rtcremove(Chan*)
1991/0911    
{
1992/0711    
	USED(c);
1991/0911    
	error(Eperm); 
} 
 
void	  
rtcwstat(Chan *c, char *dp)
1995/0822    
rtcwstat(Chan*, char*)
1991/0911    
{
1992/0711    
	USED(c, dp);
1991/0911    
	error(Eperm); 
}
1995/0822/sys/src/9/pc/devrtc.c:4,10 – 1996/0223/sys/src/9/pc/devrtc.c:4,9 (short | long)
1991/0911    
#include	"dat.h" 
#include	"fns.h"
1992/0111    
#include	"../port/error.h"
1991/0911    
#include	"devtab.h"
1991/1211    
/* 
 *  real time clock and non-volatile ram
1996/0223/sys/src/9/pc/devrtc.c:118,141 – 1997/0208/sys/src/9/pc/devrtc.c:118,148 (short | long)
1991/0911    
 
#define GETBCD(o) ((bcdclock[o]&0xf) + 10*(bcdclock[o]>>4)) 
 
long	  
rtctime(void)
1997/0208    
static long	  
_rtctime(void)
1991/0911    
{ 
	uchar bcdclock[Nbcd]; 
	Rtc rtc;
1992/1208    
	int i;
1991/0911    
1997/0208    
	/* don't do the read until the clock is no longer busy */
1992/1208    
	for(i = 0; i < 10000; i++){ 
		outb(Paddr, Status); 
		if((inb(Pdata) & 1) == 0)
1997/0208    
		if(inb(Pdata) & 0x80) 
			continue; 
 
		/* read clock values */ 
		outb(Paddr, Seconds);	bcdclock[0] = inb(Pdata); 
		outb(Paddr, Minutes);	bcdclock[1] = inb(Pdata); 
		outb(Paddr, Hours);	bcdclock[2] = inb(Pdata); 
		outb(Paddr, Mday);	bcdclock[3] = inb(Pdata); 
		outb(Paddr, Month);	bcdclock[4] = inb(Pdata); 
		outb(Paddr, Year);	bcdclock[5] = inb(Pdata); 
 
		outb(Paddr, Status); 
		if((inb(Pdata) & 0x80) == 0)
1992/1208    
			break; 
	}
1991/0911    
	outb(Paddr, Seconds);	bcdclock[0] = inb(Pdata); 
	outb(Paddr, Minutes);	bcdclock[1] = inb(Pdata); 
	outb(Paddr, Hours);	bcdclock[2] = inb(Pdata); 
	outb(Paddr, Mday);	bcdclock[3] = inb(Pdata); 
	outb(Paddr, Month);	bcdclock[4] = inb(Pdata); 
	outb(Paddr, Year);	bcdclock[5] = inb(Pdata); 
 
	/* 
	 *  convert from BCD
1996/0223/sys/src/9/pc/devrtc.c:157,166 – 1997/0208/sys/src/9/pc/devrtc.c:164,198
1991/0911    
	return rtc2sec(&rtc); 
}
1997/0208    
Lock rtlock; 
 
long 
rtctime(void) 
{ 
	int i; 
	long t, ot; 
 
	ilock(&rtlock); 
 
	/* loop till we get two reads in a row the same */ 
	t = _rtctime(); 
	for(i = 0; i < 100; i++){ 
		ot = t; 
		t = _rtctime(); 
		if(ot == t) 
			break; 
	} 
	if(i == 100) print("we are boofheads\n"); 
 
	iunlock(&rtlock); 
 
	return t; 
}
1991/0911    
long	  
rtcread(Chan *c, void *buf, long n, ulong offset) 
{ 
	ulong t, ot;
1997/0208    
	ulong t;
1993/0319    
	char *a;
1991/0911    
 
	if(c->qid.path & CHDIR)
1996/0223/sys/src/9/pc/devrtc.c:170,179 – 1997/0208/sys/src/9/pc/devrtc.c:202,207
1993/0319    
	case Qrtc: 
		qlock(&rtclock); 
		t = rtctime(); 
		do{ 
			ot = t; 
			t = rtctime();	/* make sure there's no skew */ 
		}while(t != ot); 
		qunlock(&rtclock); 
		n = readnum(offset, buf, n, t, 12); 
		return n;
1997/0208/sys/src/9/pc/devrtc.c:45,97 – 1997/0327/sys/src/9/pc/devrtc.c:45,79 (short | long)
1992/0820    
	Qnvram, 
};
1993/0319    
#define	NRTC	2
1991/0911    
Dirtab rtcdir[]={
1993/0915    
	"nvram",	{Qnvram, 0},	Nvsize,	0664, 
	"rtc",		{Qrtc, 0},	0,	0664,
1991/0911    
}; 
 
ulong rtc2sec(Rtc*); 
void sec2rtc(ulong, Rtc*); 
int *yrsize(int);
1997/0327    
static ulong rtc2sec(Rtc*); 
static void sec2rtc(ulong, Rtc*);
1991/0911    
 
void 
rtcreset(void)
1997/0327    
static Chan* 
rtcattach(char* spec)
1991/0911    
{ 
} 
                 
void 
rtcinit(void) 
{ 
} 
                 
Chan* 
rtcattach(char *spec) 
{ 
	return devattach('r', spec); 
} 
 
Chan* 
rtcclone(Chan *c, Chan *nc)
1997/0327    
static int	  
rtcwalk(Chan* c, char* name)
1991/0911    
{ 
	return devclone(c, nc);
1997/0327    
	return devwalk(c, name, rtcdir, nelem(rtcdir), devgen);
1991/0911    
} 
 
int	  
rtcwalk(Chan *c, char *name)
1997/0327    
static void	  
rtcstat(Chan* c, char* dp)
1991/0911    
{ 
	return devwalk(c, name, rtcdir, NRTC, devgen);
1997/0327    
	devstat(c, dp, rtcdir, nelem(rtcdir), devgen);
1991/0911    
} 
 
void	  
rtcstat(Chan *c, char *dp)
1997/0327    
static Chan* 
rtcopen(Chan* c, int omode)
1991/0911    
{ 
	devstat(c, dp, rtcdir, NRTC, devgen); 
} 
                 
Chan* 
rtcopen(Chan *c, int omode) 
{
1992/0819    
	omode = openmode(omode); 
	switch(c->qid.path){ 
	case Qrtc:
1997/0208/sys/src/9/pc/devrtc.c:102,117 – 1997/0327/sys/src/9/pc/devrtc.c:84,93
1993/0915    
		if(strcmp(up->user, eve)!=0)
1992/0819    
			error(Eperm); 
	}
1991/0911    
	return devopen(c, omode, rtcdir, NRTC, devgen);
1997/0327    
	return devopen(c, omode, rtcdir, nelem(rtcdir), devgen);
1991/0911    
} 
 
void
1995/0726    
rtccreate(Chan*, char*, int, ulong)
1991/0911    
{ 
	error(Eperm); 
} 
                 
void
1997/0327    
static void
1995/0822    
rtcclose(Chan*)
1991/0911    
{ 
}
1997/0208/sys/src/9/pc/devrtc.c:164,170 – 1997/0327/sys/src/9/pc/devrtc.c:140,146
1991/0911    
	return rtc2sec(&rtc); 
}
1997/0208    
Lock rtlock;
1997/0327    
static Lock rtlock;
1997/0208    
 
long 
rtctime(void)
1997/0208/sys/src/9/pc/devrtc.c:189,202 – 1997/0327/sys/src/9/pc/devrtc.c:165,178
1997/0208    
	return t; 
}
1991/0911    
long	  
rtcread(Chan *c, void *buf, long n, ulong offset)
1997/0327    
static long	  
rtcread(Chan* c, void* buf, long n, ulong offset)
1991/0911    
{
1997/0208    
	ulong t;
1993/0319    
	char *a;
1991/0911    
 
	if(c->qid.path & CHDIR) 
		return devdirread(c, buf, n, rtcdir, NRTC, devgen);
1997/0327    
		return devdirread(c, buf, n, rtcdir, nelem(rtcdir), devgen);
1991/0911    
1993/0319    
	switch(c->qid.path){ 
	case Qrtc:
1997/0208/sys/src/9/pc/devrtc.c:226,241 – 1997/0327/sys/src/9/pc/devrtc.c:202,211
1993/0319    
	return 0;
1991/0911    
}
1995/0108    
Block* 
rtcbread(Chan *c, long n, ulong offset) 
{ 
	return devbread(c, n, offset); 
} 
                 
1991/0911    
#define PUTBCD(n,o) bcdclock[o] = (n % 10) | (((n / 10) % 10)<<4) 
 
long	  
rtcwrite(Chan *c, void *buf, long n, ulong offset)
1997/0327    
static long	  
rtcwrite(Chan* c, void* buf, long n, ulong offset)
1991/0911    
{
1993/0319    
	int t; 
	char *a;
1997/0208/sys/src/9/pc/devrtc.c:306,329 – 1997/0327/sys/src/9/pc/devrtc.c:276,299
1993/0319    
	return 0;
1995/0108    
} 
 
long 
rtcbwrite(Chan *c, Block *bp, ulong offset) 
{ 
	return devbwrite(c, bp, offset);
1991/0911    
}
1997/0327    
Dev rtcdevtab = { 
	devreset, 
	devinit, 
	rtcattach, 
	devclone, 
	rtcwalk, 
	rtcstat, 
	rtcopen, 
	devcreate, 
	rtcclose, 
	rtcread, 
	devbread, 
	rtcwrite, 
	devbwrite, 
	devremove, 
	devwstat, 
};
1991/0911    
 
void
1995/0822    
rtcremove(Chan*)
1991/0911    
{ 
	error(Eperm); 
} 
                 
void
1995/0822    
rtcwstat(Chan*, char*)
1991/0911    
{ 
	error(Eperm); 
} 
                 
#define SEC2MIN 60L 
#define SEC2HOUR (60L*SEC2MIN) 
#define SEC2DAY (24L*SEC2HOUR)
1997/0208/sys/src/9/pc/devrtc.c:343,349 – 1997/0327/sys/src/9/pc/devrtc.c:313,319
1991/0911    
/* 
 *  return the days/month for the given year 
 */ 
int *
1997/0327    
static int*
1991/0911    
yrsize(int yr) 
{ 
	if((yr % 4) == 0)
1997/0208/sys/src/9/pc/devrtc.c:355,361 – 1997/0327/sys/src/9/pc/devrtc.c:325,331
1991/0911    
/* 
 *  compute seconds since Jan 1 1970 
 */ 
ulong
1997/0327    
static ulong
1991/0911    
rtc2sec(Rtc *rtc) 
{ 
	ulong secs;
1997/0208/sys/src/9/pc/devrtc.c:390,396 – 1997/0327/sys/src/9/pc/devrtc.c:360,366
1991/0911    
/* 
 *  compute rtc from seconds since Jan 1 1970 
 */ 
void
1997/0327    
static void
1991/0911    
sec2rtc(ulong secs, Rtc *rtc) 
{ 
	int d;
1997/0208/sys/src/9/pc/devrtc.c:439,447 – 1997/0327/sys/src/9/pc/devrtc.c:409,434
1991/0911    
	return; 
}
1992/1006    
1997/0327    
static Lock nvramlock;
1992/1006    
uchar 
nvramread(int offset)
1997/0327    
nvramread(int addr)
1992/1006    
{ 
	outb(Paddr, offset); 
	return inb(Pdata);
1997/0327    
	uchar data; 
 
	lock(&nvramlock); 
	outb(Paddr, addr); 
	data = inb(Pdata); 
	unlock(&nvramlock); 
 
	return data; 
} 
 
void 
nvramwrite(int addr, uchar data) 
{ 
	lock(&nvramlock); 
	outb(Paddr, addr); 
	outb(Pdata, data); 
	unlock(&nvramlock);
1992/1006    
}
1997/0327/sys/src/9/pc/devrtc.c:277,282 – 1997/0408/sys/src/9/pc/devrtc.c:277,285 (short | long)
1995/0108    
}
1997/0327    
Dev rtcdevtab = {
1997/0408    
	'r', 
	"rtc",
1997/0327    
	devreset, 
	devinit, 
	rtcattach,
1997/0408/sys/src/9/pc/devrtc.c:166,175 – 1998/0319/sys/src/9/pc/devrtc.c:166,176 (short | long)
Change dev read and write to use vlong offset.
rsc Fri Mar 4 12:44:25 2005
1997/0208    
}
1997/0327    
static long	  
rtcread(Chan* c, void* buf, long n, ulong offset)
1998/0319    
rtcread(Chan* c, void* buf, long n, vlong off)
1991/0911    
{
1997/0208    
	ulong t;
1993/0319    
	char *a;
1998/0319    
	ulong offset = off;
1991/0911    
 
	if(c->qid.path & CHDIR)
1997/0327    
		return devdirread(c, buf, n, rtcdir, nelem(rtcdir), devgen);
1997/0408/sys/src/9/pc/devrtc.c:205,211 – 1998/0319/sys/src/9/pc/devrtc.c:206,212
1991/0911    
#define PUTBCD(n,o) bcdclock[o] = (n % 10) | (((n / 10) % 10)<<4)
1997/0327    
static long	  
rtcwrite(Chan* c, void* buf, long n, ulong offset)
1998/0319    
rtcwrite(Chan* c, void* buf, long n, vlong off)
1991/0911    
{
1993/0319    
	int t; 
	char *a;
1997/0408/sys/src/9/pc/devrtc.c:213,218 – 1998/0319/sys/src/9/pc/devrtc.c:214,220
1991/0911    
	ulong secs; 
	uchar bcdclock[Nbcd]; 
	char *cp, *ep;
1998/0319    
	ulong offset = off;
1991/0911    
 
	if(offset!=0) 
		error(Ebadarg);
1998/0319/sys/src/9/pc/devrtc.c:319,327 – 1999/0113/sys/src/9/pc/devrtc.c:319,327 (short | long)
1991/0911    
 *  return the days/month for the given year 
 */
1997/0327    
static int*
1991/0911    
yrsize(int yr)
1999/0113    
yrsize(int y)
1991/0911    
{ 
	if((yr % 4) == 0)
1999/0113    
	if((y%4) == 0 && ((y%100) != 0 || (y%400) == 0))
1991/0911    
		return ldmsize; 
	else 
		return dmsize;
1999/0113/sys/src/9/pc/devrtc.c:38,44 – 1999/0129/sys/src/9/pc/devrtc.c:38,43 (short | long)
1991/0911    
	int	year; 
}; 
 
QLock rtclock;	/* mutex on clock operations */
1992/0820    
enum{ 
	Qrtc = 1,
1999/0113/sys/src/9/pc/devrtc.c:140,146 – 1999/0129/sys/src/9/pc/devrtc.c:139,145
1991/0911    
	return rtc2sec(&rtc); 
}
1997/0327    
static Lock rtlock;
1999/0129    
static Lock nvrtlock;
1997/0208    
 
long 
rtctime(void)
1999/0113/sys/src/9/pc/devrtc.c:148,154 – 1999/0129/sys/src/9/pc/devrtc.c:147,153
1997/0208    
	int i; 
	long t, ot; 
 
	ilock(&rtlock);
1999/0129    
	ilock(&nvrtlock);
1997/0208    
 
	/* loop till we get two reads in a row the same */ 
	t = _rtctime();
1999/0113/sys/src/9/pc/devrtc.c:160,166 – 1999/0129/sys/src/9/pc/devrtc.c:159,165
1997/0208    
	} 
	if(i == 100) print("we are boofheads\n"); 
 
	iunlock(&rtlock);
1999/0129    
	iunlock(&nvrtlock);
1997/0208    
 
	return t; 
}
1999/0113/sys/src/9/pc/devrtc.c:169,175 – 1999/0129/sys/src/9/pc/devrtc.c:168,174
1998/0319    
rtcread(Chan* c, void* buf, long n, vlong off)
1991/0911    
{
1997/0208    
	ulong t;
1993/0319    
	char *a;
1999/0129    
	char *a, *start;
1998/0319    
	ulong offset = off;
1991/0911    
 
	if(c->qid.path & CHDIR)
1999/0113/sys/src/9/pc/devrtc.c:177,194 – 1999/0129/sys/src/9/pc/devrtc.c:176,192
1991/0911    
1993/0319    
	switch(c->qid.path){ 
	case Qrtc: 
		qlock(&rtclock); 
		t = rtctime(); 
		qunlock(&rtclock); 
		n = readnum(offset, buf, n, t, 12); 
		return n; 
	case Qnvram: 
		a = buf; 
		if(waserror()){ 
			qunlock(&rtclock); 
			nexterror(); 
		} 
		qlock(&rtclock);
1999/0129    
		if(n == 0) 
			return 0; 
		if(n > Nvsize) 
			n = Nvsize; 
		a = start = smalloc(n); 
 
		ilock(&nvrtlock);
1993/0319    
		for(t = offset; t < offset + n; t++){ 
			if(t >= Nvsize) 
				break;
1999/0113/sys/src/9/pc/devrtc.c:195,202 – 1999/0129/sys/src/9/pc/devrtc.c:193,208
1993/0319    
			outb(Paddr, Nvoff+t); 
			*a++ = inb(Pdata); 
		} 
		qunlock(&rtclock);
1999/0129    
		iunlock(&nvrtlock); 
 
		if(waserror()){ 
			free(start); 
			nexterror(); 
		} 
		memmove(buf, start, t - offset);
1993/0319    
		poperror();
1999/0129    
 
		free(start);
1993/0319    
		return t - offset; 
	} 
	error(Ebadarg);
1999/0113/sys/src/9/pc/devrtc.c:209,215 – 1999/0129/sys/src/9/pc/devrtc.c:215,221
1998/0319    
rtcwrite(Chan* c, void* buf, long n, vlong off)
1991/0911    
{
1993/0319    
	int t; 
	char *a;
1999/0129    
	char *a, *start;
1991/0911    
	Rtc rtc; 
	ulong secs; 
	uchar bcdclock[Nbcd];
1999/0113/sys/src/9/pc/devrtc.c:248,254 – 1999/0129/sys/src/9/pc/devrtc.c:254,260
1993/0319    
		/* 
		 *  write the clock 
		 */ 
		qlock(&rtclock);
1999/0129    
		ilock(&nvrtlock);
1993/0319    
		outb(Paddr, Seconds);	outb(Pdata, bcdclock[0]); 
		outb(Paddr, Minutes);	outb(Pdata, bcdclock[1]); 
		outb(Paddr, Hours);	outb(Pdata, bcdclock[2]);
1999/0113/sys/src/9/pc/devrtc.c:255,269 – 1999/0129/sys/src/9/pc/devrtc.c:261,283
1993/0319    
		outb(Paddr, Mday);	outb(Pdata, bcdclock[3]); 
		outb(Paddr, Month);	outb(Pdata, bcdclock[4]); 
		outb(Paddr, Year);	outb(Pdata, bcdclock[5]); 
		qunlock(&rtclock);
1999/0129    
		iunlock(&nvrtlock);
1993/0319    
		return n; 
	case Qnvram: 
		a = buf;
1999/0129    
		if(n == 0) 
			return 0; 
		if(n > Nvsize) 
			n = Nvsize; 
	 
		start = a = smalloc(n);
1993/0319    
		if(waserror()){ 
			qunlock(&rtclock);
1999/0129    
			free(start);
1993/0319    
			nexterror(); 
		} 
		qlock(&rtclock);
1999/0129    
		memmove(a, buf, n); 
		poperror(); 
 
		ilock(&nvrtlock);
1993/0319    
		for(t = offset; t < offset + n; t++){ 
			if(t >= Nvsize) 
				break;
1999/0113/sys/src/9/pc/devrtc.c:270,277 – 1999/0129/sys/src/9/pc/devrtc.c:284,292
1993/0319    
			outb(Paddr, Nvoff+t); 
			outb(Pdata, *a++); 
		} 
		qunlock(&rtclock); 
		poperror();
1999/0129    
		iunlock(&nvrtlock); 
 
		free(start);
1993/0319    
		return t - offset; 
	} 
	error(Ebadarg);
1999/0113/sys/src/9/pc/devrtc.c:414,430 – 1999/0129/sys/src/9/pc/devrtc.c:429,443
1991/0911    
	return; 
}
1992/1006    
1997/0327    
static Lock nvramlock; 
                 
1992/1006    
uchar
1997/0327    
nvramread(int addr)
1992/1006    
{
1997/0327    
	uchar data; 
 
	lock(&nvramlock);
1999/0129    
	ilock(&nvrtlock);
1997/0327    
	outb(Paddr, addr); 
	data = inb(Pdata); 
	unlock(&nvramlock);
1999/0129    
	iunlock(&nvrtlock);
1997/0327    
 
	return data; 
}
1999/0113/sys/src/9/pc/devrtc.c:432,439 – 1999/0129/sys/src/9/pc/devrtc.c:445,452
1997/0327    
void 
nvramwrite(int addr, uchar data) 
{ 
	lock(&nvramlock);
1999/0129    
	ilock(&nvrtlock);
1997/0327    
	outb(Paddr, addr); 
	outb(Pdata, data); 
	unlock(&nvramlock);
1999/0129    
	iunlock(&nvrtlock);
1992/1006    
}
Too many diffs (26 > 25). Stopping.


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