4.4BSD/usr/src/sys/sparc/sparc/clock.c
/*
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Lawrence Berkeley Laboratory.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)clock.c 8.1 (Berkeley) 6/11/93
*
* from: $Header: clock.c,v 1.17 92/11/26 03:04:47 torek Exp $ (LBL)
*/
/*
* Clock driver. This is the id prom (``eeprom'') driver as well
* and includes the timer register functions too.
*/
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/proc.h>
#include <sys/resourcevar.h>
#ifdef GPROF
#include <sys/gmon.h>
#endif
#include <vm/vm.h>
#include <machine/autoconf.h>
#include <sparc/sparc/clockreg.h>
#include <sparc/sparc/intreg.h>
#include <sparc/sparc/timerreg.h>
/*
* Statistics clock interval and variance, in usec. Variance must be a
* power of two. Since this gives us an even number, not an odd number,
* we discard one case and compensate. That is, a variance of 1024 would
* give us offsets in [0..1023]. Instead, we take offsets in [1..1023].
* This is symmetric about the point 512, or statvar/2, and thus averages
* to that value (assuming uniform random numbers).
*/
/* XXX fix comment to match value */
int statvar = 8192;
int statmin; /* statclock interval - 1/2*variance */
static int clockmatch __P((struct device *, struct cfdata *, void *));
static void clockattach __P((struct device *, struct device *, void *));
struct cfdriver clockcd =
{ NULL, "clock", clockmatch, clockattach, DV_DULL, sizeof(struct device) };
static int timermatch __P((struct device *, struct cfdata *, void *));
static void timerattach __P((struct device *, struct device *, void *));
struct cfdriver timercd =
{ NULL, "timer", timermatch, timerattach, DV_DULL, sizeof(struct device) };
/*
* The OPENPROM calls the clock the "eeprom", so we have to have our
* own special match function to call it the "clock".
*/
static int
clockmatch(parent, cf, aux)
struct device *parent;
struct cfdata *cf;
void *aux;
{
return (strcmp("eeprom", ((struct romaux *)aux)->ra_name) == 0);
}
/* ARGSUSED */
static void
clockattach(parent, self, aux)
struct device *parent, *self;
void *aux;
{
register int h;
register struct clockreg *cl;
struct romaux *ra = aux;
printf(": %s (eeprom)\n", getpropstring(ra->ra_node, "model"));
/*
* We ignore any existing virtual address as we need to map
* this read-only and make it read-write only temporarily,
* whenever we read or write the clock chip. The clock also
* contains the ID ``PROM'', and I have already had the pleasure
* of reloading the cpu type, Ethernet address, etc, by hand from
* the console FORTH interpreter. I intend not to enjoy it again.
*/
cl = (struct clockreg *)mapiodev(ra->ra_paddr, sizeof *clockreg);
pmap_changeprot(kernel_pmap, (vm_offset_t)clockreg, VM_PROT_READ, 1);
h = cl->cl_idprom.id_machine << 24;
h |= cl->cl_idprom.id_hostid[0] << 16;
h |= cl->cl_idprom.id_hostid[1] << 8;
h |= cl->cl_idprom.id_hostid[0];
hostid = h;
clockreg = cl;
}
/*
* The OPENPROM calls the timer the "counter-timer".
*/
static int
timermatch(parent, cf, aux)
struct device *parent;
struct cfdata *cf;
void *aux;
{
return (strcmp("counter-timer", ((struct romaux *)aux)->ra_name) == 0);
}
/* ARGSUSED */
static void
timerattach(parent, self, aux)
struct device *parent, *self;
void *aux;
{
register struct romaux *ra = aux;
printf("\n");
/*
* This time, we ignore any existing virtual address because
* we have a fixed virtual address for the timer, to make
* microtime() faster.
*/
(void)mapdev(ra->ra_paddr, TIMERREG_VA, sizeof(struct timerreg));
/* should link interrupt handlers here, rather than compiled-in? */
}
/*
* Write en/dis-able clock registers. We coordinate so that several
* writers can run simultaneously.
*/
void
clk_wenable(onoff)
int onoff;
{
register int s;
register vm_prot_t prot;/* nonzero => change prot */
static int writers;
s = splhigh();
if (onoff)
prot = writers++ == 0 ? VM_PROT_READ|VM_PROT_WRITE : 0;
else
prot = --writers == 0 ? VM_PROT_READ : 0;
splx(s);
if (prot)
pmap_changeprot(kernel_pmap, (vm_offset_t)clockreg, prot, 1);
}
/*
* XXX this belongs elsewhere
*/
void
myetheraddr(cp)
u_char *cp;
{
register struct clockreg *cl = clockreg;
cp[0] = cl->cl_idprom.id_ether[0];
cp[1] = cl->cl_idprom.id_ether[1];
cp[2] = cl->cl_idprom.id_ether[2];
cp[3] = cl->cl_idprom.id_ether[3];
cp[4] = cl->cl_idprom.id_ether[4];
cp[5] = cl->cl_idprom.id_ether[5];
}
/*
* Delay: wait for `about' n microseconds to pass.
* This is easy to do on the SparcStation since we have
* freerunning microsecond timers -- no need to guess at
* cpu speed factors. We just wait for it to change n times
* (if we calculated a limit, we might overshoot, and precision
* is irrelevant here---we want less object code).
*/
delay(n)
register int n;
{
register int c, t;
if (timercd.cd_ndevs == 0)
panic("delay");
c = TIMERREG->t_c10.t_counter;
while (--n >= 0) {
while ((t = TIMERREG->t_c10.t_counter) == c)
continue;
c = t;
}
}
/*
* Set up the real-time and statistics clocks. Leave stathz 0 only if
* no alternative timer is available.
*
* The frequencies of these clocks must be an even number of microseconds.
*/
cpu_initclocks()
{
register int statint, minint;
if (1000000 % hz) {
printf("cannot get %d Hz clock; using 100 Hz\n", hz);
hz = 100;
tick = 1000000 / hz;
}
if (stathz == 0)
stathz = hz;
if (1000000 % stathz) {
printf("cannot get %d Hz statclock; using 100 Hz\n", stathz);
stathz = 100;
}
profhz = stathz; /* always */
statint = 1000000 / stathz;
minint = statint / 2 + 100;
while (statvar > minint)
statvar >>= 1;
TIMERREG->t_c10.t_limit = tmr_ustolim(tick);
TIMERREG->t_c14.t_limit = tmr_ustolim(statint);
statmin = statint - (statvar >> 1);
ienab_bis(IE_L14 | IE_L10);
}
/*
* Dummy setstatclockrate(), since we know profhz==hz.
*/
/* ARGSUSED */
void
setstatclockrate(newhz)
int newhz;
{
/* nothing */
}
/*
* Level 10 (clock) interrupts. If we are using the FORTH PROM for
* console input, we need to check for that here as well, and generate
* a software interrupt to read it.
*/
int
clockintr(cap)
void *cap;
{
register int discard;
extern int rom_console_input;
/* read the limit register to clear the interrupt */
discard = TIMERREG->t_c10.t_limit;
hardclock((struct clockframe *)cap);
if (rom_console_input && cnrom())
setsoftint();
return (1);
}
/*
* Level 14 (stat clock) interrupt handler.
*/
int
statintr(cap)
void *cap;
{
register int discard;
register u_long newint, r, var;
/* read the limit register to clear the interrupt */
discard = TIMERREG->t_c14.t_limit;
statclock((struct clockframe *)cap);
/*
* Compute new randomized interval. The intervals are uniformly
* distributed on [statint - statvar / 2, statint + statvar / 2],
* and therefore have mean statint, giving a stathz frequency clock.
*/
var = statvar;
do {
r = random() & (var - 1);
} while (r == 0);
newint = statmin + r;
TIMERREG->t_c14.t_limit = tmr_ustolim(newint);
return (1);
}
/*
* BCD to decimal and decimal to BCD.
*/
#define FROMBCD(x) (((x) >> 4) * 10 + ((x) & 0xf))
#define TOBCD(x) (((x) / 10 * 16) + ((x) % 10))
#define SECDAY (24 * 60 * 60)
#define SECYR (SECDAY * 365)
#define LEAPYEAR(y) (((y) & 3) == 0)
/*
* This code is defunct after 2068.
* Will Unix still be here then??
*/
const short dayyr[12] =
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
chiptotime(sec, min, hour, day, mon, year)
register int sec, min, hour, day, mon, year;
{
register int days, yr;
sec = FROMBCD(sec);
min = FROMBCD(min);
hour = FROMBCD(hour);
day = FROMBCD(day);
mon = FROMBCD(mon);
year = FROMBCD(year) + YEAR0;
/* simple sanity checks */
if (year < 70 || mon < 1 || mon > 12 || day < 1 || day > 31)
return (0);
days = 0;
for (yr = 70; yr < year; yr++)
days += LEAPYEAR(yr) ? 366 : 365;
days += dayyr[mon - 1] + day - 1;
if (LEAPYEAR(yr) && mon > 2)
days++;
/* now have days since Jan 1, 1970; the rest is easy... */
return (days * SECDAY + hour * 3600 + min * 60 + sec);
}
struct chiptime {
int sec;
int min;
int hour;
int wday;
int day;
int mon;
int year;
};
timetochip(c)
register struct chiptime *c;
{
register int t, t2, t3, now = time.tv_sec;
/* compute the year */
t2 = now / SECDAY;
t3 = (t2 + 2) % 7; /* day of week */
c->wday = TOBCD(t3 + 1);
t = 69;
while (t2 >= 0) { /* whittle off years */
t3 = t2;
t++;
t2 -= LEAPYEAR(t) ? 366 : 365;
}
c->year = t;
/* t3 = month + day; separate */
t = LEAPYEAR(t);
for (t2 = 1; t2 < 12; t2++)
if (t3 < dayyr[t2] + (t && t2 > 1))
break;
/* t2 is month */
c->mon = t2;
c->day = t3 - dayyr[t2 - 1] + 1;
if (t && t2 > 2)
c->day--;
/* the rest is easy */
t = now % SECDAY;
c->hour = t / 3600;
t %= 3600;
c->min = t / 60;
c->sec = t % 60;
c->sec = TOBCD(c->sec);
c->min = TOBCD(c->min);
c->hour = TOBCD(c->hour);
c->day = TOBCD(c->day);
c->mon = TOBCD(c->mon);
c->year = TOBCD(c->year - YEAR0);
}
/*
* Set up the system's time, given a `reasonable' time value.
*/
inittodr(base)
time_t base;
{
register struct clockreg *cl = clockreg;
int sec, min, hour, day, mon, year;
int badbase = 0;
if (base < 5 * SECYR) {
printf("WARNING: preposterous time in file system\n");
/* not going to use it anyway, if the chip is readable */
base = 21*SECYR + 186*SECDAY + SECDAY/2;
badbase = 1;
}
clk_wenable(1);
cl->cl_csr |= CLK_READ; /* enable read (stop time) */
sec = cl->cl_sec;
min = cl->cl_min;
hour = cl->cl_hour;
day = cl->cl_mday;
mon = cl->cl_month;
year = cl->cl_year;
cl->cl_csr &= ~CLK_READ; /* time wears on */
clk_wenable(0);
if ((time.tv_sec = chiptotime(sec, min, hour, day, mon, year)) == 0) {
printf("WARNING: bad date in battery clock");
/*
* Believe the time in the file system for lack of
* anything better, resetting the clock.
*/
time.tv_sec = base;
if (!badbase)
resettodr();
} else {
int deltat = time.tv_sec - base;
if (deltat < 0)
deltat = -deltat;
if (deltat < 2 * SECDAY)
return;
printf("WARNING: clock %s %d days",
time.tv_sec < base ? "lost" : "gained", deltat / SECDAY);
}
printf(" -- CHECK AND RESET THE DATE!\n");
}
/*
* Reset the clock based on the current time.
* Used when the current clock is preposterous, when the time is changed,
* and when rebooting. Do nothing if the time is not yet known, e.g.,
* when crashing during autoconfig.
*/
resettodr()
{
register struct clockreg *cl;
struct chiptime c;
if (!time.tv_sec || (cl = clockreg) == NULL)
return;
timetochip(&c);
clk_wenable(1);
cl->cl_csr |= CLK_WRITE; /* enable write */
cl->cl_sec = c.sec;
cl->cl_min = c.min;
cl->cl_hour = c.hour;
cl->cl_wday = c.wday;
cl->cl_mday = c.day;
cl->cl_month = c.mon;
cl->cl_year = c.year;
cl->cl_csr &= ~CLK_WRITE; /* load them up */
clk_wenable(0);
}