Subversion Repositories planix.SVN

/*

 * bcm2835 timers

 *	System timers run at 1MHz (timers 1 and 2 are used by GPU)

 *	ARM timer usually runs at 250MHz (may be slower in low power modes)

 *	Cycle counter runs at 700MHz (unless overclocked)

 *    All are free-running up-counters

 *

 * Use system timer 3 (64 bits) for hzclock interrupts and fastticks

 * Use ARM timer (32 bits) for perfticks

 * Use ARM timer to force immediate interrupt

 * Use cycle counter for cycles()

 */

#include "u.h"

#include "../port/lib.h"

#include "mem.h"

#include "dat.h"

#include "fns.h"

#include "io.h"

enum {

	SYSTIMERS	= VIRTIO+0x3000,

	ARMTIMER	= VIRTIO+0xB400,

	SystimerFreq	= 1*Mhz,

	MaxPeriod	= SystimerFreq / HZ,

	MinPeriod	= SystimerFreq / (100*HZ),

};

typedef struct Systimers Systimers;

typedef struct Armtimer Armtimer;

struct Systimers {

	u32int	cs;

	u32int	clo;

	u32int	chi;

	u32int	c0;

	u32int	c1;

	u32int	c2;

	u32int	c3;

};

struct Armtimer {

	u32int	load;

	u32int	val;

	u32int	ctl;

	u32int	irqack;

	u32int	irq;

	u32int	maskedirq;

	u32int	reload;

	u32int	predivider;

	u32int	count;

};

enum {

	CntPrescaleShift= 16,	/* freq is sys_clk/(prescale+1) */

	CntPrescaleMask	= 0xFF,

	CntEnable	= 1<<9,

	TmrDbgHalt	= 1<<8,

	TmrEnable	= 1<<7,

	TmrIntEnable	= 1<<5,

	TmrPrescale1	= 0x00<<2,

	TmrPrescale16	= 0x01<<2,

	TmrPrescale256	= 0x02<<2,

	CntWidth16	= 0<<1,

	CntWidth32	= 1<<1,

};

static void

clockintr(Ureg *ureg, void *)

{

	Systimers *tn;

	tn = (Systimers*)SYSTIMERS;

	/* dismiss interrupt */

	tn->cs = 1<<3;

	timerintr(ureg, 0);

}

void

clockshutdown(void)

{

	Armtimer *tm;

	tm = (Armtimer*)ARMTIMER;

	tm->ctl = 0;

	wdogoff();

}

void

clockinit(void)

{

	Systimers *tn;

	Armtimer *tm;

	u32int t0, t1, tstart, tend;

	tn = (Systimers*)SYSTIMERS;

	tm = (Armtimer*)ARMTIMER;

	tm->load = 0;

	tm->ctl = TmrPrescale1|CntEnable|CntWidth32;

	tstart = tn->clo;

	do{

		t0 = lcycles();

	}while(tn->clo == tstart);

	tend = tstart + 10000;

	do{

		t1 = lcycles();

	}while(tn->clo != tend);

	t1 -= t0;

	m->cpuhz = 100 * t1;

	m->cpumhz = (m->cpuhz + Mhz/2 - 1) / Mhz;

	m->cyclefreq = m->cpuhz;

	tn->c3 = tn->clo - 1;

	intrenable(IRQtimer3, clockintr, nil, 0, "clock");

}

void

timerset(uvlong next)

{

	Systimers *tn;

	vlong now, period;

	tn = (Systimers*)SYSTIMERS;

	now = fastticks(nil);

	period = next - fastticks(nil);

	if(period < MinPeriod)

		next = now + MinPeriod;

	else if(period > MaxPeriod)

		next = now + MaxPeriod;

	tn->c3 = (ulong)next;

}

uvlong

fastticks(uvlong *hz)

{

	Systimers *tn;

	ulong lo, hi;

	tn = (Systimers*)SYSTIMERS;

	if(hz)

		*hz = SystimerFreq;

	do{

		hi = tn->chi;

		lo = tn->clo;

	}while(tn->chi != hi);

	m->fastclock = (uvlong)hi<<32 | lo;

	return m->fastclock;

}

ulong

perfticks(void)

{

	Armtimer *tm;

	tm = (Armtimer*)ARMTIMER;

	return tm->count;

}

void

armtimerset(int n)

{

	Armtimer *tm;

	tm = (Armtimer*)ARMTIMER;

	if(n > 0){

		tm->ctl |= TmrEnable|TmrIntEnable;

		tm->load = n;

	}else{

		tm->load = 0;

		tm->ctl &= ~(TmrEnable|TmrIntEnable);

		tm->irq = 1;

	}

}

ulong

µs(void)

{

	if(SystimerFreq != 1*Mhz)

		return fastticks2us(fastticks(nil));

	return fastticks(nil);

}

void

microdelay(int n)

{

	Systimers *tn;

	u32int now, diff;

	tn = (Systimers*)SYSTIMERS;

	diff = n + 1;

	now = tn->clo;

	while(tn->clo - now < diff)

		;

}

void

delay(int n)

{

	while(--n >= 0)

		microdelay(1000);

}