/*
* cortex-a clocks; excludes tegra 2 SoC clocks
*
* cortex-a processors include private `global' and local timers
* at soc.scu + 0x200 (global) and + 0x600 (local).
* the global timer is a single count-up timer shared by all cores
* but with per-cpu comparator and auto-increment registers.
* a local count-down timer can be used as a watchdog.
*
* v7 arch provides a 32-bit count-up cycle counter (at about 1GHz in our case)
* but it's unsuitable as our source of fastticks, because it stops advancing
* when the cpu is suspended by WFI.
*/
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "arm.h"

enum {
       Debug           = 0,

       Basetickfreq    = Mhz,                  /* soc.µs rate in Hz */
       /* the local timers seem to run at half the expected rate */
       Clockfreqbase   = 250*Mhz / 2,  /* private timer rate (PERIPHCLK/2) */
       Tcycles         = Clockfreqbase / HZ,   /* cycles per clock tick */

       MinPeriod       = Tcycles / 100,
       MaxPeriod       = Tcycles,

       Dogtimeout      = Dogsectimeout * Clockfreqbase,
};

typedef struct Ltimer Ltimer;
typedef struct Pglbtmr Pglbtmr;
typedef struct Ploctmr Ploctmr;

/*
* cortex-a private-intr local timer registers.  all cpus see their
* own local timers at the same base address.
*/
struct Ltimer {
       ulong   load;           /* new value + 1 */
       ulong   cnt;            /* counts down */
       ulong   ctl;
       ulong   isr;

       /* watchdog only */
       ulong   wdrst;
       ulong   wddis;          /* wo */

       ulong   _pad0[2];
};
struct Ploctmr {
       Ltimer  loc;
       Ltimer  wd;
};

enum {
       /* ctl bits */
       Tmrena  = 1<<0,         /* timer enabled */
       Wdogena = Tmrena,       /* watchdog enabled */
       Xreload = 1<<1,         /* reload on intr; periodic interrupts */
       Tintena = 1<<2,         /* enable irq 29 at cnt==0 (30 for watchdog) */
       Wdog    = 1<<3,         /* watchdog, not timer, mode */
       Xsclrshift = 8,
       Xsclrmask = MASK(8),

       /* isr bits */
       Xisrclk = 1<<0,         /* write to clear */

       /* wdrst bits */
       Wdrst   = 1<<0,

       /* wddis values */
       Wdon    = 1,
       Wdoff1  = 0x12345678,   /* send these two to switch to timer mode */
       Wdoff2  = 0x87654321,
};

/* cortex-a private-intr globl timer registers */
struct Pglbtmr {
       ulong   cnt[2];         /* counts up; little-endian uvlong */
       ulong   ctl;
       ulong   isr;
       ulong   cmp[2];         /* little-endian uvlong */
       ulong   inc;
};

enum {
       /* unique ctl bits (otherwise see X* above) */
       Gcmp    = 1<<1,
//      Gtintena= 1<<2,         /* enable irq 27 */
       Gincr   = 1<<3,
};

/*
* until 5[cl] inline vlong ops, avoid them where possible,
* they are currently slow function calls.
*/
typedef union Vlong Vlong;
union Vlong {
       uvlong  uvl;
       struct {                        /* little-endian */
               ulong   low;
               ulong   high;
       };
};

static int fired;
static int ticking[MAXMACH];

/* no lock is needed to update our local timer.  splhi keeps it tight. */
static void
setltimer(Ltimer *tn, ulong ticks)
{
       int s;

       assert(ticks <= Clockfreqbase);
       s = splhi();
       tn->load = ticks - 1;
       coherence();
       tn->ctl = Tmrena | Tintena | Xreload;
       coherence();
       splx(s);
}

static void
ckstuck(int cpu, long myticks, long histicks)
{
       if (labs(histicks - myticks) > HZ) {
//              iprint("cpu%d: clock ticks %ld (vs myticks %ld cpu0 %ld); "
//                      "apparently stopped\n",
//                      cpu, histicks, myticks, MACHP(0)->ticks);
               if (!ticking[cpu])
                       panic("cpu%d: clock not interrupting", cpu);
       }
}

static void
mpclocksanity(void)
{
       int cpu, mycpu;
       long myticks, histicks;

       if (conf.nmach <= 1 || active.exiting || navailcpus == 0)
               return;

       mycpu = m->machno;
       myticks = m->ticks;
       if (myticks == HZ)
               ticking[mycpu] = 1;

       if (myticks < 5*HZ)
               return;

       for (cpu = 0; cpu < navailcpus; cpu++) {
               if (cpu == mycpu)
                       continue;
               histicks = MACHP(cpu)->ticks;
               if (myticks == 5*HZ || histicks > 1)
                       ckstuck(cpu, myticks, histicks);
       }
}

static void
clockintr(Ureg* ureg, void *arg)
{
       Ltimer *wd, *tn;
       Ploctmr *lt;

       lt = (Ploctmr *)arg;
       tn = &lt->loc;
       tn->isr = Xisrclk;
       coherence();

       timerintr(ureg, 0);

#ifdef watchdog_not_bloody_useless
       /* appease the dogs */
       wd = &lt->wd;
       if (wd->cnt == 0 &&
           (wd->ctl & (Wdog | Wdogena | Tintena)) == (Wdog | Wdogena))
               panic("cpu%d: zero watchdog count but no system reset",
                       m->machno);
       wd->load = Dogtimeout - 1;
       coherence();
#endif
       SET(wd); USED(wd);
       tegclockintr();

       mpclocksanity();
}

void
clockprod(Ureg *ureg)
{
       Ltimer *tn;

       timerintr(ureg, 0);
       tegclockintr();
       if (m->machno != 0) {           /* cpu1 gets stuck */
               tn = &((Ploctmr *)soc.loctmr)->loc;
               setltimer(tn, Tcycles);
       }
}

static void
clockreset(Ltimer *tn)
{
       if (probeaddr((uintptr)tn) < 0)
               panic("no clock at %#p", tn);
       tn->ctl = 0;
       coherence();
}

void
watchdogoff(Ltimer *wd)
{
       wd->ctl &= ~Wdogena;
       coherence();
       wd->wddis = Wdoff1;
       coherence();
       wd->wddis = Wdoff2;
       coherence();
}

/* clear any pending watchdog intrs or causes */
void
wdogclrintr(Ltimer *wd)
{
#ifdef watchdog_not_bloody_useless
       wd->isr = Xisrclk;
       coherence();
       wd->wdrst = Wdrst;
       coherence();
#endif
       USED(wd);
}

/*
* stop clock interrupts on this cpu and disable the local watchdog timer,
* and, if on cpu0, shutdown the shared tegra2 watchdog timer.
*/
void
clockshutdown(void)
{
       Ploctmr *lt;

       lt = (Ploctmr *)soc.loctmr;
       clockreset(&lt->loc);
       watchdogoff(&lt->wd);

       tegclockshutdown();
}

enum {
       Instrs          = 10*Mhz,
};

/* we assume that perfticks are microseconds */
static long
issue1loop(void)
{
       register int i;
       long st;

       i = Instrs;
       st = perfticks();
       do {
               --i; --i; --i; --i; --i; --i; --i; --i; --i; --i;
               --i; --i; --i; --i; --i; --i; --i; --i; --i; --i;
               --i; --i; --i; --i; --i; --i; --i; --i; --i; --i;
               --i; --i; --i; --i; --i; --i; --i; --i; --i; --i;
               --i; --i; --i; --i; --i; --i; --i; --i; --i; --i;
               --i; --i; --i; --i; --i; --i; --i; --i; --i; --i;
               --i; --i; --i; --i; --i; --i; --i; --i; --i; --i;
               --i; --i; --i; --i; --i; --i; --i; --i; --i; --i;
               --i; --i; --i; --i; --i; --i; --i; --i; --i; --i;
               --i; --i; --i; --i; --i; --i; --i; --i; --i;
       } while(--i >= 0);
       return perfticks() - st;
}

static long
issue2loop(void)
{
       register int i, j;
       long st;

       i = Instrs / 2;                 /* j gets half the decrements */
       j = 0;
       st = perfticks();
       do {
                    --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;

               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
               --i; --j; --i; --j; --i; --j; --i; --j; --i; --j;
       } while(--i >= 0);
       return perfticks() - st;
}

/* estimate instructions/s. */
static void
guessmips(long (*loop)(void), char *lab)
{
       int s;
       long tcks;

       do {
               s = splhi();
               tcks = loop();
               splx(s);
               if (tcks < 0)
                       iprint("again...");
       } while (tcks < 0);
       /*
        * Instrs instructions took tcks ticks @ Basetickfreq Hz.
        * round the result.
        */
       s = (((vlong)Basetickfreq * Instrs) / tcks + 500000) / 1000000;
       if (Debug)
               iprint("%ud mips (%s-issue)", s, lab);
       USED(s);
}

void
wdogintr(Ureg *, void *ltmr)
{
#ifdef watchdog_not_bloody_useless
       Ltimer *wd;

       wd = ltmr;
       fired++;
       wdogclrintr(wd);
#endif
       USED(ltmr);
}

static void
ckcounting(Ltimer *lt)
{
       ulong old;

       old = lt->cnt;
       if (old == lt->cnt)
               delay(1);
       if (old == lt->cnt)
               panic("cpu%d: watchdog timer not counting down", m->machno);
}

/* test fire with interrupt to see that it's working */
static void
ckwatchdog(Ltimer *wd)
{
#ifdef watchdog_not_bloody_useless
       int s;

       fired = 0;
       wd->load = Tcycles - 1;
       coherence();
       /* Tintena is supposed to be ignored in watchdog mode */
       wd->ctl |= Wdogena | Tintena;
       coherence();

       ckcounting(wd);

       s = spllo();
       delay(2 * 1000/HZ);
       splx(s);
       if (!fired)
               /* useless local watchdog */
               iprint("cpu%d: local watchdog failed to interrupt\n", m->machno);
       /* clean up */
       wd->ctl &= ~Wdogena;
       coherence();
#endif
       USED(wd);
}

static void
startwatchdog(void)
{
#ifdef watchdog_not_bloody_useless
       Ltimer *wd;
       Ploctmr *lt;

       lt = (Ploctmr *)soc.loctmr;
       wd = &lt->wd;
       watchdogoff(wd);
       wdogclrintr(wd);
       irqenable(Wdtmrirq, wdogintr, wd, "watchdog");

       ckwatchdog(wd);

       /* set up for normal use, causing reset */
       wd->ctl &= ~Tintena;                    /* reset, don't interrupt */
       coherence();
       wd->ctl |= Wdog;
       coherence();
       wd->load = Dogtimeout - 1;
       coherence();
       wd->ctl |= Wdogena;
       coherence();

       ckcounting(wd);
#endif
}

static void
clock0init(Ltimer *tn)
{
       int s;
       ulong old, fticks;

       /*
        * calibrate fastclock
        */
       s = splhi();
       tn->load = ~0ul >> 1;
       coherence();
       tn->ctl = Tmrena;
       coherence();

       old = perfticks();
       fticks = tn->cnt;
       delay(1);
       fticks = abs(tn->cnt - fticks);
       old = perfticks() - old;
       splx(s);
       if (Debug)
               iprint("cpu%d: fastclock %ld/%ldµs = %ld fastticks/µs (MHz)\n",
                       m->machno, fticks, old, (fticks + old/2 - 1) / old);
       USED(fticks, old);

       if (Debug)
               iprint("cpu%d: ", m->machno);
       guessmips(issue1loop, "single");
       if (Debug)
               iprint(", ");
       guessmips(issue2loop, "dual");
       if (Debug)
               iprint("\n");

       /*
        * m->delayloop should be the number of delay loop iterations
        * needed to consume 1 ms.  2 is instr'ns in the delay loop.
        */
       m->delayloop = m->cpuhz / (1000 * 2);
//      iprint("cpu%d: m->delayloop = %lud\n", m->machno, m->delayloop);

       tegclock0init();
}

/*
* the local timer is the interrupting timer and does not
* participate in measuring time.  It is initially set to HZ.
*/
void
clockinit(void)
{
       ulong old;
       Ltimer *tn;
       Ploctmr *lt;

       clockshutdown();

       /* turn my cycle counter on */
       cpwrsc(0, CpCLD, CpCLDena, CpCLDenacyc, 1<<31);

       /* turn all my counters on and clear my cycle counter */
       cpwrsc(0, CpCLD, CpCLDena, CpCLDenapmnc, 1<<2 | 1);

       /* let users read my cycle counter directly */
       cpwrsc(0, CpCLD, CpCLDuser, CpCLDenapmnc, 1);

       /* verify µs counter sanity */
       tegclockinit();

       lt = (Ploctmr *)soc.loctmr;
       tn = &lt->loc;
       if (m->machno == 0)
               irqenable(Loctmrirq, clockintr, lt, "clock");
       else
               intcunmask(Loctmrirq);

       /*
        * verify sanity of local timer
        */
       tn->load = Clockfreqbase / 1000;
       tn->isr = Xisrclk;
       coherence();
       tn->ctl = Tmrena;
       coherence();

       old = tn->cnt;
       delay(5);
       /* m->ticks won't be incremented here because timersinit hasn't run. */
       if (tn->cnt == old)
               panic("cpu%d: clock not ticking at all", m->machno);
       else if ((long)tn->cnt > 0)
               panic("cpu%d: clock ticking slowly", m->machno);

       if (m->machno == 0)
               clock0init(tn);

       /* if pci gets stuck, maybe one of the many watchdogs will nuke us. */
       startwatchdog();

       /*
        *  desynchronize the processor clocks so that they all don't
        *  try to resched at the same time.
        */
       delay(m->machno*2);
       setltimer(tn, Tcycles);
}

/* our fastticks are at 1MHz (Basetickfreq), so the conversion is trivial. */
ulong
µs(void)
{
       return fastticks2us(fastticks(nil));
}

/* Tval is supposed to be in fastticks units. */
void
timerset(Tval next)
{
       int s;
       long offset;
       Ltimer *tn;

       tn = &((Ploctmr *)soc.loctmr)->loc;
       s = splhi();
       offset = fastticks2us(next - fastticks(nil));
       /* offset is now in µs (MHz); convert to Clockfreqbase Hz. */
       offset *= Clockfreqbase / Mhz;
       if(offset < MinPeriod)
               offset = MinPeriod;
       else if(offset > MaxPeriod)
               offset = MaxPeriod;

       setltimer(tn, offset);
       splx(s);
}

static ulong
cpucycles(void) /* cpu clock rate, except when waiting for intr (unused) */
{
       ulong v;

       /* reads 32-bit cycle counter (counting up) */
//      v = cprdsc(0, CpCLD, CpCLDcyc, 0);
       v = getcyc();                           /* fast asm */
       /* keep it non-negative; prevent m->fastclock ever going to 0 */
       return v == 0? 1: v;
}

long
lcycles(void)
{
       return perfticks();
}

uvlong
fastticks(uvlong *hz)
{
       int s;
       ulong newticks;
       Vlong *fcp;

       if(hz)
               *hz = Basetickfreq;

       fcp = (Vlong *)&m->fastclock;
       /* avoid reentry on interrupt or trap, to prevent recursion */
       s = splhi();
       newticks = perfticks();
       if(newticks < fcp->low)         /* low word must have wrapped */
               fcp->high++;
       fcp->low = newticks;
       splx(s);

       if (fcp->low == 0 && fcp->high == 0 && m->ticks > HZ/10)
               panic("fastticks: zero m->fastclock; ticks %lud fastclock %#llux",
                       m->ticks, m->fastclock);
       return m->fastclock;
}

void
microdelay(int l)
{
       for (l = l * (vlong)m->delayloop / 1000; --l >= 0; )
               ;
}

void
delay(int l)
{
       int i, d;

       d = m->delayloop;
       while(--l >= 0)
               for (i = d; --i >= 0; )
                       ;
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.