461 lines
7 KiB
C
461 lines
7 KiB
C
#include "u.h"
|
|
#include "../port/lib.h"
|
|
#include "mem.h"
|
|
#include "dat.h"
|
|
#include "fns.h"
|
|
#include "../port/error.h"
|
|
|
|
/*
|
|
* real time clock and non-volatile ram
|
|
*/
|
|
|
|
enum {
|
|
Paddr= 0x70, /* address port */
|
|
Pdata= 0x71, /* data port */
|
|
|
|
Seconds= 0x00,
|
|
Minutes= 0x02,
|
|
Hours= 0x04,
|
|
Mday= 0x07,
|
|
Month= 0x08,
|
|
Year= 0x09,
|
|
Status= 0x0A,
|
|
|
|
Nvoff= 128, /* where usable nvram lives */
|
|
Nvsize= 256,
|
|
|
|
Nbcd= 6,
|
|
};
|
|
|
|
typedef struct Rtc Rtc;
|
|
struct Rtc
|
|
{
|
|
int sec;
|
|
int min;
|
|
int hour;
|
|
int mday;
|
|
int mon;
|
|
int year;
|
|
};
|
|
|
|
|
|
enum{
|
|
Qdir = 0,
|
|
Qrtc,
|
|
Qnvram,
|
|
};
|
|
|
|
Dirtab rtcdir[]={
|
|
".", {Qdir, 0, QTDIR}, 0, 0555,
|
|
"nvram", {Qnvram, 0}, Nvsize, 0664,
|
|
"rtc", {Qrtc, 0}, 0, 0664,
|
|
};
|
|
|
|
static ulong rtc2sec(Rtc*);
|
|
static void sec2rtc(ulong, Rtc*);
|
|
|
|
void
|
|
rtcinit(void)
|
|
{
|
|
if(ioalloc(Paddr, 2, 0, "rtc/nvr") < 0)
|
|
panic("rtcinit: ioalloc failed");
|
|
}
|
|
|
|
static Chan*
|
|
rtcattach(char* spec)
|
|
{
|
|
return devattach('r', spec);
|
|
}
|
|
|
|
static Walkqid*
|
|
rtcwalk(Chan* c, Chan *nc, char** name, int nname)
|
|
{
|
|
return devwalk(c, nc, name, nname, rtcdir, nelem(rtcdir), devgen);
|
|
}
|
|
|
|
static int
|
|
rtcstat(Chan* c, uchar* dp, int n)
|
|
{
|
|
return devstat(c, dp, n, rtcdir, nelem(rtcdir), devgen);
|
|
}
|
|
|
|
static Chan*
|
|
rtcopen(Chan* c, int omode)
|
|
{
|
|
omode = openmode(omode);
|
|
switch((ulong)c->qid.path){
|
|
case Qrtc:
|
|
if(strcmp(up->user, eve)!=0 && omode!=OREAD)
|
|
error(Eperm);
|
|
break;
|
|
case Qnvram:
|
|
if(strcmp(up->user, eve)!=0)
|
|
error(Eperm);
|
|
}
|
|
return devopen(c, omode, rtcdir, nelem(rtcdir), devgen);
|
|
}
|
|
|
|
static void
|
|
rtcclose(Chan*)
|
|
{
|
|
}
|
|
|
|
#define GETBCD(o) ((bcdclock[o]&0xf) + 10*(bcdclock[o]>>4))
|
|
|
|
static long
|
|
_rtctime(void)
|
|
{
|
|
uchar bcdclock[Nbcd];
|
|
Rtc rtc;
|
|
int i;
|
|
|
|
/* don't do the read until the clock is no longer busy */
|
|
for(i = 0; i < 10000; i++){
|
|
outb(Paddr, Status);
|
|
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)
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* convert from BCD
|
|
*/
|
|
rtc.sec = GETBCD(0);
|
|
rtc.min = GETBCD(1);
|
|
rtc.hour = GETBCD(2);
|
|
rtc.mday = GETBCD(3);
|
|
rtc.mon = GETBCD(4);
|
|
rtc.year = GETBCD(5);
|
|
|
|
/*
|
|
* the world starts jan 1 1970
|
|
*/
|
|
if(rtc.year < 70)
|
|
rtc.year += 2000;
|
|
else
|
|
rtc.year += 1900;
|
|
return rtc2sec(&rtc);
|
|
}
|
|
|
|
static Lock nvrtlock;
|
|
|
|
long
|
|
rtctime(void)
|
|
{
|
|
int i;
|
|
long t, ot;
|
|
|
|
ilock(&nvrtlock);
|
|
|
|
/* 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(&nvrtlock);
|
|
|
|
return t;
|
|
}
|
|
|
|
static long
|
|
rtcread(Chan* c, void* buf, long n, vlong off)
|
|
{
|
|
ulong t;
|
|
char *a, *start;
|
|
ulong offset = off;
|
|
|
|
if(c->qid.type & QTDIR)
|
|
return devdirread(c, buf, n, rtcdir, nelem(rtcdir), devgen);
|
|
|
|
switch((ulong)c->qid.path){
|
|
case Qrtc:
|
|
t = rtctime();
|
|
n = readnum(offset, buf, n, t, 12);
|
|
return n;
|
|
case Qnvram:
|
|
if(n == 0)
|
|
return 0;
|
|
if(n > Nvsize)
|
|
n = Nvsize;
|
|
a = start = smalloc(n);
|
|
|
|
ilock(&nvrtlock);
|
|
for(t = offset; t < offset + n; t++){
|
|
if(t >= Nvsize)
|
|
break;
|
|
outb(Paddr, Nvoff+t);
|
|
*a++ = inb(Pdata);
|
|
}
|
|
iunlock(&nvrtlock);
|
|
|
|
if(waserror()){
|
|
free(start);
|
|
nexterror();
|
|
}
|
|
memmove(buf, start, t - offset);
|
|
poperror();
|
|
|
|
free(start);
|
|
return t - offset;
|
|
}
|
|
error(Ebadarg);
|
|
return 0;
|
|
}
|
|
|
|
#define PUTBCD(n,o) bcdclock[o] = (n % 10) | (((n / 10) % 10)<<4)
|
|
|
|
static long
|
|
rtcwrite(Chan* c, void* buf, long n, vlong off)
|
|
{
|
|
int t;
|
|
char *a, *start;
|
|
Rtc rtc;
|
|
ulong secs;
|
|
uchar bcdclock[Nbcd];
|
|
char *cp, *ep;
|
|
ulong offset = off;
|
|
|
|
if(offset!=0)
|
|
error(Ebadarg);
|
|
|
|
|
|
switch((ulong)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);
|
|
|
|
/*
|
|
* write the clock
|
|
*/
|
|
ilock(&nvrtlock);
|
|
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]);
|
|
iunlock(&nvrtlock);
|
|
return n;
|
|
case Qnvram:
|
|
if(n == 0)
|
|
return 0;
|
|
if(n > Nvsize)
|
|
n = Nvsize;
|
|
|
|
start = a = smalloc(n);
|
|
if(waserror()){
|
|
free(start);
|
|
nexterror();
|
|
}
|
|
memmove(a, buf, n);
|
|
poperror();
|
|
|
|
ilock(&nvrtlock);
|
|
for(t = offset; t < offset + n; t++){
|
|
if(t >= Nvsize)
|
|
break;
|
|
outb(Paddr, Nvoff+t);
|
|
outb(Pdata, *a++);
|
|
}
|
|
iunlock(&nvrtlock);
|
|
|
|
free(start);
|
|
return t - offset;
|
|
}
|
|
error(Ebadarg);
|
|
return 0;
|
|
}
|
|
|
|
Dev rtcdevtab = {
|
|
'r',
|
|
"rtc",
|
|
|
|
devreset,
|
|
rtcinit,
|
|
devshutdown,
|
|
rtcattach,
|
|
rtcwalk,
|
|
rtcstat,
|
|
rtcopen,
|
|
devcreate,
|
|
rtcclose,
|
|
rtcread,
|
|
devbread,
|
|
rtcwrite,
|
|
devbwrite,
|
|
devremove,
|
|
devwstat,
|
|
};
|
|
|
|
#define SEC2MIN 60L
|
|
#define SEC2HOUR (60L*SEC2MIN)
|
|
#define SEC2DAY (24L*SEC2HOUR)
|
|
|
|
/*
|
|
* days per month plus days/year
|
|
*/
|
|
static int dmsize[] =
|
|
{
|
|
365, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
|
|
};
|
|
static int ldmsize[] =
|
|
{
|
|
366, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
|
|
};
|
|
|
|
/*
|
|
* return the days/month for the given year
|
|
*/
|
|
static int*
|
|
yrsize(int y)
|
|
{
|
|
if((y%4) == 0 && ((y%100) != 0 || (y%400) == 0))
|
|
return ldmsize;
|
|
else
|
|
return dmsize;
|
|
}
|
|
|
|
/*
|
|
* compute seconds since Jan 1 1970
|
|
*/
|
|
static ulong
|
|
rtc2sec(Rtc *rtc)
|
|
{
|
|
ulong secs;
|
|
int i;
|
|
int *d2m;
|
|
|
|
secs = 0;
|
|
|
|
/*
|
|
* seconds per year
|
|
*/
|
|
for(i = 1970; i < rtc->year; i++){
|
|
d2m = yrsize(i);
|
|
secs += d2m[0] * SEC2DAY;
|
|
}
|
|
|
|
/*
|
|
* seconds per month
|
|
*/
|
|
d2m = yrsize(rtc->year);
|
|
for(i = 1; i < rtc->mon; i++)
|
|
secs += d2m[i] * SEC2DAY;
|
|
|
|
secs += (rtc->mday-1) * SEC2DAY;
|
|
secs += rtc->hour * SEC2HOUR;
|
|
secs += rtc->min * SEC2MIN;
|
|
secs += rtc->sec;
|
|
|
|
return secs;
|
|
}
|
|
|
|
/*
|
|
* compute rtc from seconds since Jan 1 1970
|
|
*/
|
|
static void
|
|
sec2rtc(ulong secs, Rtc *rtc)
|
|
{
|
|
int d;
|
|
long hms, day;
|
|
int *d2m;
|
|
|
|
/*
|
|
* break initial number into days
|
|
*/
|
|
hms = secs % SEC2DAY;
|
|
day = secs / SEC2DAY;
|
|
if(hms < 0) {
|
|
hms += SEC2DAY;
|
|
day -= 1;
|
|
}
|
|
|
|
/*
|
|
* generate hours:minutes:seconds
|
|
*/
|
|
rtc->sec = hms % 60;
|
|
d = hms / 60;
|
|
rtc->min = d % 60;
|
|
d /= 60;
|
|
rtc->hour = d;
|
|
|
|
/*
|
|
* year number
|
|
*/
|
|
if(day >= 0)
|
|
for(d = 1970; day >= *yrsize(d); d++)
|
|
day -= *yrsize(d);
|
|
else
|
|
for (d = 1970; day < 0; d--)
|
|
day += *yrsize(d-1);
|
|
rtc->year = d;
|
|
|
|
/*
|
|
* generate month
|
|
*/
|
|
d2m = yrsize(rtc->year);
|
|
for(d = 1; day >= d2m[d]; d++)
|
|
day -= d2m[d];
|
|
rtc->mday = day + 1;
|
|
rtc->mon = d;
|
|
|
|
return;
|
|
}
|
|
|
|
uchar
|
|
nvramread(int addr)
|
|
{
|
|
uchar data;
|
|
|
|
ilock(&nvrtlock);
|
|
outb(Paddr, addr);
|
|
data = inb(Pdata);
|
|
iunlock(&nvrtlock);
|
|
|
|
return data;
|
|
}
|
|
|
|
void
|
|
nvramwrite(int addr, uchar data)
|
|
{
|
|
ilock(&nvrtlock);
|
|
outb(Paddr, addr);
|
|
outb(Pdata, data);
|
|
iunlock(&nvrtlock);
|
|
}
|