 @@ -1,14 +1,14 @@
-/*	$NetBSD: timer.c,v 1.29 2011/07/17 23:18:23 mrg Exp $ */
+/*	$NetBSD: timer.c,v 1.29.8.1 2018/03/13 16:48:05 snj Exp $ */
 /*
  * Copyright (c) 1992, 1993
  *	The Regents of the University of California.  All rights reserved.
  * Copyright (c) 1994 Gordon W. Ross
  * Copyright (c) 1993 Adam Glass
  * Copyright (c) 1996 Paul Kranenburg
  * Copyright (c) 1996
  * 	The President and Fellows of Harvard College. 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.
 @@ -50,108 +50,153 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)clock.c	8.1 (Berkeley) 6/11/93
  */
 /*
  * Kernel clocks provided by "timer" device.  The hardclock is provided by
  * the timer register (aka system counter).  The statclock is provided by
  * per CPU counter register(s) (aka processor counter(s)).
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: timer.c,v 1.29 2011/07/17 23:18:23 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: timer.c,v 1.29.8.1 2018/03/13 16:48:05 snj Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/systm.h>
 #include <sys/timetc.h>
 #include <machine/autoconf.h>
 #include <sys/bus.h>
 #include <sparc/sparc/timerreg.h>
 #include <sparc/sparc/timervar.h>
 static struct intrhand level10;
 static struct intrhand level14;
 static u_int timer_get_timecount(struct timecounter *);
 /*
  * timecounter local state
  */
 static struct counter {
-	volatile u_int *cntreg;	/* counter register */
+	__cpu_simple_lock_t lock; /* protects access to offset, reg, last* */
 	volatile u_int *cntreg;	/* counter register to read */
 	u_int limit;		/* limit we count up to */
 	u_int offset;		/* accumulated offet due to wraps */
 	u_int shift;		/* scaling for valid bits */
 	u_int mask;		/* valid bit mask */
-} cntr;
+	u_int lastcnt;		/* the last* values are used to notice */
 	u_int lastres;		/* and fix up cases where it would appear */
 	u_int lastoffset;	/* time went backwards. */
 } cntr __aligned(CACHE_LINE_SIZE);
 /*
  * define timecounter
  */
 static struct timecounter counter_timecounter = {
-	timer_get_timecount,	/* get_timecount */
+	.tc_get_timecount =	timer_get_timecount,
-,			/* no poll_pps */
+	.tc_poll_pps =		NULL,
-	~0u,			/* counter_mask */
+	.tc_counter_mask =	~0u,
-,                      /* frequency - set at initialisation */
+	.tc_frequency =		0,
-	"timer-counter",	/* name */
+	.tc_name =		"timer-counter",
-,			/* quality */
+	.tc_quality =		100,
-	&cntr			/* private reference */
+	.tc_priv =		&cntr,
 };
 /*
  * timer_get_timecount provide current counter value
  */
 __attribute__((__optimize__("Os")))
 static u_int
 timer_get_timecount(struct timecounter *tc)
+{
-	struct counter *ctr = (struct counter *)tc->tc_priv;
+	u_int cnt, res, fixup, offset;
 	u_int c, res, r;
 	int s;
 	/*
 	 * We use splhigh/__cpu_simple_lock here as we don't want
 	 * any mutex or lockdebug overhead.  The lock protects a
 	 * bunch of the members of cntr that are written here to
 	 * deal with the various minor races to be observed and
 	 * worked around.
 	 */
 	s = splhigh();
-	res = c = *ctr->cntreg;
+	__cpu_simple_lock(&cntr.lock);
 	res = cnt = *cntr.cntreg;
 	res  &= ~TMR_LIMIT;
 	offset = cntr.offset;
-	if (c != res) {
+	/*
-		r = ctr->limit;
+	 * There are 3 cases here:
 	 * - limit reached, interrupt not yet processed.
 	 * - count reset but offset the same, race between handling
 	 *   the interrupt and tickle_tc() updating the offset.
 	 * - normal case.
+	 *
 	 * For the first two cases, add the limit so that we avoid
 	 * time going backwards.
 	 */
 	if (cnt != res) {
 		fixup = cntr.limit;
 	} else if (res < cntr.lastcnt && offset == cntr.lastoffset) {
 		fixup = cntr.limit;
 	} else {
-		r = 0;
+		fixup = 0;
+	}
 	cntr.lastcnt = res;
 	cntr.lastoffset = offset;
-	res >>= ctr->shift;
+	res >>= cntr.shift;
-	res  &= ctr->mask;
+	res  &= cntr.mask;
-	res += r + ctr->offset;
+	res += fixup + offset;
 	/*
 	 * This handles early-boot cases where the counter resets twice
 	 * before the offset is updated, and we have a stupid check to
 	 * ensure overflow hasn't happened.
 	 */
 	if (res < cntr.lastres && res > (TMR_MASK+1) << 3)
 		res = cntr.lastres + 1;
 	cntr.lastres = res;
 	__cpu_simple_unlock(&cntr.lock);
 	splx(s);
 	return res;
+}
 void
 tickle_tc(void)
+{
 	if (timecounter->tc_get_timecount == timer_get_timecount) {
 		/*
 		 * This could be protected by cntr.lock/splhigh but the update
 		 * happens at IPL10 already and as a 32 bit value it should
 		 * never be seen as a partial update, so skip it here.  This
 		 * also probably slows down the actual offset update, making
 		 * one of the cases above more likely to need the workaround.
 		 */
 		cntr.offset += cntr.limit;
+	}
+}
 /*
  * sun4/sun4c/sun4m common timer attach code
  */
 void
 timerattach(volatile int *cntreg, volatile int *limreg)
+{
 	u_int prec = 0, t0;
 	void    (*sched_intr_fn)(void *);
 @@ -179,26 +224,28 @@ timerattach(volatile int *cntreg, volati
 		t0 = (t0 >> TMR_SHIFT) & TMR_MASK;
 		t1 = (t1 >> TMR_SHIFT) & TMR_MASK;
 		if (t1 >= t0 + 100)
 			break;
+	}
 	/* find lowest active bit */
 	for (t0 = 0; t0 < TMR_SHIFT; t0++)
 		if ((1 << t0) & prec)
 			break;
 	__cpu_simple_lock_init(&cntr.lock);
 	cntr.shift = t0;
 	cntr.mask = (1 << (31-t0))-1;
 	counter_timecounter.tc_frequency = 1000000 * (TMR_SHIFT - t0 + 1);
 	printf(": delay constant %d, frequency = %" PRIu64 " Hz\n",
 	       timerblurb, counter_timecounter.tc_frequency);
 #if defined(SUN4) || defined(SUN4C)
 	if (CPU_ISSUN4 || CPU_ISSUN4C) {
 		timer_init = timer_init_4;
 		sched_intr_fn = schedintr;
 		level10.ih_fun = clockintr_4;
 		level14.ih_fun = statintr_4;
 @@ -209,38 +256,42 @@ timerattach(volatile int *cntreg, volati
 	if (CPU_ISSUN4M) {
 		timer_init = timer_init_4m;
 #if defined(MULTIPROCESSOR)
 		if (sparc_ncpus > 1)
 			sched_intr_fn = schedintr_4m;
 		else
 #endif
 			sched_intr_fn = schedintr;
 		level10.ih_fun = clockintr_4m;
 		level14.ih_fun = statintr_4m;
 		cntr.limit = tmr_ustolim4m(tick);
+	}
 #endif
 	/* link interrupt handlers */
 	intr_establish(10, 0, &level10, NULL, true);
 	intr_establish(14, 0, &level14, NULL, true);
 	/* Establish a soft interrupt at a lower level for schedclock */
 	sched_cookie = sparc_softintr_establish(IPL_SCHED, sched_intr_fn, NULL);
 	if (sched_cookie == NULL)
 		panic("timerattach: cannot establish schedintr");
 	cntr.cntreg = cntreg;
 	cntr.limit >>= cntr.shift;
 	/* start at non-zero, so that cntr.oldoffset is less */
 	cntr.offset = cntr.limit;
 	tc_init(&counter_timecounter);
+}
 /*
  * Both sun4 and sun4m can attach a timer on obio.
  * The sun4m OPENPROM calls the timer the "counter".
  * The sun4 timer must be probed.
  */
 static int
 timermatch_obio(device_t parent, cfdata_t cf, void *aux)
+{
 #if defined(SUN4) || defined(SUN4M)
 	union obio_attach_args *uoba = aux;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: timer_sun4m.c,v 1.28 2011/09/01 08:43:24 martin Exp $	*/
+/*	$NetBSD: timer_sun4m.c,v 1.28.8.1 2018/03/13 16:48:05 snj Exp $	*/
 /*
  * Copyright (c) 1992, 1993
  *	The Regents of the University of California.  All rights reserved.
  * Copyright (c) 1994 Gordon W. Ross
  * Copyright (c) 1993 Adam Glass
  * Copyright (c) 1996 Paul Kranenburg
  * Copyright (c) 1996
  * 	The President and Fellows of Harvard College. 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.
 @@ -48,43 +48,43 @@
  * 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
  */
 /*
  * Sun4m timer support.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: timer_sun4m.c,v 1.28 2011/09/01 08:43:24 martin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: timer_sun4m.c,v 1.28.8.1 2018/03/13 16:48:05 snj Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/systm.h>
 #include <sys/cpu.h>
 #include <machine/autoconf.h>
 #include <sys/bus.h>
 #include <sparc/sparc/vaddrs.h>
 #include <sparc/sparc/cpuvar.h>
 #include <sparc/sparc/timerreg.h>
 #include <sparc/sparc/timervar.h>
-struct timer_4m		*timerreg4m;
+static struct timer_4m		*timerreg4m;
 #define	counterreg4m	cpuinfo.counterreg_4m
 /*
  * 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.
  */
 void
 timer_init_4m(void)
+{
 	struct cpu_info *cpi;
 	int n;
 @@ -132,29 +132,33 @@ clockintr_4m(void *cap)
 	/*
 	 * XXX this needs to be fixed in a more general way
 	 * problem is that the kernel enables interrupts and THEN
 	 * sets up clocks. In between there's an opportunity to catch
 	 * a timer interrupt - if we call hardclock() at that point we'll
 	 * panic
 	 * so for now just bail when cold
+	 *
 	 * For MP, we defer calling hardclock() to the schedintr so
 	 * that we call it on all cpus.
 	 */
 	if (cold)
 		return 0;
 	kpreempt_disable();
 	/* read the limit register to clear the interrupt */
 	/* Read the limit register to clear the interrupt. */
 	*((volatile int *)&timerreg4m->t_limit);
 	/* Update the timecounter offset. */
 	tickle_tc();
 	hardclock((struct clockframe *)cap);
 	kpreempt_enable();
 	return (1);
+}
 /*
  * Level 14 (stat clock) interrupts from processor counter.
  */
 int
 statintr_4m(void *cap)
+{
 	struct clockframe *frame = cap;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: timerreg.h,v 1.9 2005/11/16 03:00:23 uwe Exp $ */
+/*	$NetBSD: timerreg.h,v 1.9.118.1 2018/03/13 16:48:05 snj Exp $ */
 /*
  * 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.
 @@ -110,19 +110,22 @@ struct counter_4m {		/* counter that int
 /*
  * Compute a limit that causes the timer to fire every n microseconds.
  * The Sun4c requires that the timer register be initialized for n+1
  * microseconds, while the Sun4m requires it be initialized for n. Thus
  * the two versions of this function.
+ *
  * Note that the manual for the chipset used in the Sun4m suggests that
  * the timer be set at n+0.5 microseconds; in practice, this produces
  * a 50 ppm clock skew, which means that the 0.5 should not be there...
  */
 #define	tmr_ustolim(n)	(((n) + 1) << TMR_SHIFT)
-/*efine	TMR_SHIFT4M	9		-* shift to obtain microseconds */
+#define	TMR_SHIFT4M	9		/* shift to obtain microseconds */
-/*efine tmr_ustolim4m(n)	(((2*(n)) + 1) << TMR_SHIFT4M)*/
+#if 1
 #define tmr_ustolim4m(n)	(((2*(n)) + 1) << TMR_SHIFT4M)
 #else
 #define tmr_ustolim4m(n)	((n) << TMR_SHIFT)
 #endif
 /* The number of microseconds represented by a counter register value */
 #define tmr_cnttous(c)	((((c) >> TMR_SHIFT) & TMR_MASK) - 1)