static void calibrate(void)
{
static RTIME cpu_tbase;
static unsigned long apic_tbase;
times.cpu_time = rd_CPU_ts();
#ifdef CONFIG_X86_LOCAL_APIC
if (params.mp) {
times.apic_time = apic_read(APIC_TMCCT);
}
#endif /* CONFIG_X86_LOCAL_APIC */
if (times.intrs < 0) {
cpu_tbase = times.cpu_time;
apic_tbase = times.apic_time;
}
times.intrs++;
if (++count == reset_count) {
count = 0;
times.cpu_time -= cpu_tbase;
times.apic_time = apic_tbase - times.apic_time;
rtf_put(0, ×, sizeof(times));
}
rt_pend_linux_irq(TIMER_8254_IRQ);
#ifdef CONFIG_X86_LOCAL_APIC
if (params.mp) {
unsigned temp = (apic_read(APIC_ICR) & (~0xCDFFF)) | (APIC_DM_FIXED | APIC_DEST_ALLINC | LOCAL_TIMER_VECTOR);
apic_write(APIC_ICR, temp);
}
#endif /* CONFIG_X86_LOCAL_APIC */
}
static int rt_timer_tick_ext(int irq, unsigned long data)
{
RTIME t;
int jit;
if (loops++ < INILOOPS) {
t0 = rdtsc();
} else {
t = rdtsc();
if (use_parport) {
outb(bit = 1 - bit, PARPORT);
}
if ((jit = abs((int)(t - t0) - bus_period)) > maxj) {
maxj = jit;
if (maxj > bus_threshold) {
int msg;
msg = imuldiv(maxj, 1000000000, CPU_FREQ);
rtf_put(0, &msg, sizeof(msg));
}
}
t0 = t;
}
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
rt_times.linux_time += rt_times.linux_tick;
hard_sti();
rt_pend_linux_irq(TIMER_8254_IRQ);
return 0;
}
hard_sti();
return 1;
}
static int rt_timer_tick_ext(int irq, unsigned long data)
{
int ret = 1;
cpu_used[NR_RT_CPUS]++;
if (passed++ < 5) {
t0 = rdtsc();
} else {
t = rdtsc();
if ((jit = t - t0 - imuldiv(rt_times.periodic_tick, CPU_FREQ, FREQ_8254)) < 0) {
jit = -jit;
}
if (jit > maxj) {
maxj = jit;
}
t0 = t;
}
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
rt_times.linux_time += rt_times.linux_tick;
rt_pend_linux_irq(TIMER_8254_IRQ);
ret = 0;
}
rt_sched_lock();
if (Mode) {
rt_sem_signal(&sem);
} else {
rt_task_resume(&thread);
}
rt_sched_unlock();
return ret;
}
static void timer_tick(void)
{
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
rt_times.linux_time += rt_times.linux_tick;
rt_pend_linux_irq(TIMER_8254_IRQ);
}
if (run) {
if (rt_waiting_return(tasknode, taskport)) {
overuns++;
}
switch(run) {
case 1: RT_sem_signal(tasknode, -taskport, rmt_sem);
rt_printk("SEM SIGNAL %d\n", ++cnt);
break;
case 2:
RT_task_resume(tasknode, -taskport, rmt_task);
rt_printk("TASK RESUME %d\n", ++cnt);
break;
case 3:
RT_send_if(tasknode, -taskport, rmt_task, run);
rt_printk("TASK SEND %d\n", ++cnt);
break;
}
}
}
static void rt_timer_tick(void)
{
cpu_used[NR_RT_CPUS]++;
if (passed++ < 5) {
t0 = rdtsc();
} else {
t = rdtsc();
if ((jit = t - t0 - imuldiv(rt_times.periodic_tick, CPU_FREQ, FREQ_8254)) < 0) {
jit = -jit;
}
if (jit > maxj) {
maxj = jit;
}
t0 = t;
}
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
rt_times.linux_time += rt_times.linux_tick;
rt_pend_linux_irq(TIMER_8254_IRQ);
}
if (Mode) {
rt_sem_signal(&sem);
} else {
rt_task_resume(&thread);
}
}
static void rtai_handler(int irqa, void *idx)
{
int i;
i = (long)idx;
cnt[i]++;
rt_pend_linux_irq(irq[i]);
}
static void tmrisr(int irq)
{
int cnt;
outb(0x00, 0x43);
cnt = inb(0x40);
cnt |= (inb(0x40) << 8);
if (cnt > tmrcnt) {
tmrcnt = cnt;
}
rt_pend_linux_irq(irq);
}
int irq_handler(int irq, xnintr_t *intr)
{
int r = ((int (*)(void *))intr->isr)(intr);
if (r & ENABLE_IRQ) {
rt_enable_irq((intr)->irq);
}
if (r & PEND_IRQ) {
rt_pend_linux_irq(intr->irq);
}
++intr->cnt;
return 0;
}
void c_handler (void)
{
hal_root_domain->irqs[IRQ].acknowledge(IRQ);
save_fpcr_and_enable_fpu(cr0);
save_fpenv(saved_fpu_reg);
restore_fpenv(my_fpu_reg);
++cnt;
++fcnt;
save_fpenv(my_fpu_reg);
restore_fpenv(saved_fpu_reg);
restore_fpcr(cr0);
rt_pend_linux_irq(IRQ);
}
static void rt_timer_tick(void)
{
char wakeup;
rtf_put(CMDF, &wakeup, sizeof(wakeup));
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
if (rt_times.linux_tick > 0) {
rt_times.linux_time += rt_times.linux_tick;
}
rt_pend_linux_irq(TIMER_8254_IRQ);
}
}
static void rt_timer_tick(void)
{
struct rt_tasklet_struct *tasklet;
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
if (rt_times.linux_tick > 0) {
rt_times.linux_time += rt_times.linux_tick;
}
rt_pend_linux_irq(TIMER_8254_IRQ);
}
if ((tasklet = rt_find_tasklet_by_id(nam2num("TSKLET")))) {
rt_exec_tasklet(tasklet);
}
}
static void timer_tick(void)
{
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
if (rt_times.linux_tick) {
rt_times.linux_time += rt_times.linux_tick;
}
rt_pend_linux_irq(TIMER_8254_IRQ);
}
if (run) {
if (rt_waiting_return(tasknode, taskport)) {
overuns++;
}
rt_task_resume(&sup_task);
}
}
void rt_request_timer(void (*handler)(void), unsigned int tick, int unused)
{
RTIME t;
extern union rtai_tsc rtai_tsc;
unsigned long flags;
TRACE_RTAI_TIMER(TRACE_RTAI_EV_TIMER_REQUEST, handler, tick);
flags = hard_lock_all();
/*
* sync w/jiffie, wait for a OS timer 0 match and clear the match bit
*/
rtai_tsc.tsc = 0;
/* wait for a timer match 0 and clear the match bit */
do {
} while ( (signed long)(OSMR0 - OSCR) >= 0 );
OSSR = OSSR_M0;
/* set up rt_times structure */
rt_times.linux_tick = LATCH;
rt_times.periodic_tick = tick > 0 && tick < (RTIME)rt_times.linux_tick ? tick : rt_times.linux_tick;
rt_times.tick_time = t = rdtsc();
rt_times.intr_time = t + (RTIME)rt_times.periodic_tick;
rt_times.linux_time = t + (RTIME)rt_times.linux_tick;
/* Trick the scheduler - set this our way. */
// tuned.setup_time_TIMER_CPUNIT = (int)(~(~0 >> 1)) + 1; /* smallest negative + 1 - for extra safety:-) */
/* update Match-register */
rt_set_timer_match_reg(rt_times.periodic_tick);
irq_desc[TIMER_8254_IRQ].action->handler = soft_timer_interrupt;
rt_free_global_irq(TIMER_8254_IRQ);
rt_request_global_irq(TIMER_8254_IRQ, handler);
/*
* pend linux timer irq to handle current jiffie
*/
rt_pend_linux_irq(TIMER_8254_IRQ);
hard_unlock_all(flags);
return;
}
static void calibrate(void)
{
static int count = 0, gcount = -1;
static unsigned long tbase, time, temp;
time = apic_read(APIC_TMCCT);
if (gcount < 0) {
tbase = time;
}
gcount++;
if (++count == RESET_COUNT) {
time = tbase - time;
count = imuldiv(time, CLOCK_TICK_RATE, gcount*LATCH);
printk("\n->>> MEASURED APIC_FREQ: %d (hz) [%d (s)], IN USE %d (hz) <<<-\n", count, gcount/100 + 1, FREQ_APIC);
count = 0;
}
rt_pend_linux_irq(TIMER_8254_IRQ);
temp = (apic_read(APIC_ICR) & (~0xCDFFF)) |
(APIC_DM_FIXED | APIC_DEST_ALLINC | LOCAL_TIMER_VECTOR);
apic_write(APIC_ICR, temp);
}
