← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to hw/mips_timer.c

  • Committer: ths
  • Date: 2007-06-17 15:32:30 UTC
  • Revision ID: git-v1:ffb04fcf089865952592f1f8855c2848d4514a89
Allow relative paths for the interpreter prefix in linux-user emulation.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@2984 c046a42c-6fe2-441c-8c8c-71466251a162

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/mips_timer.c
1
 
#include "hw.h"
2
 
#include "mips.h"
3
 
#include "qemu-timer.h"
 
1
#include "vl.h"
4
2
 
5
 
#define TIMER_FREQ      100 * 1000 * 1000
 
3
void cpu_mips_irqctrl_init (void)
 
4
{
 
5
}
6
6
 
7
7
/* XXX: do not use a global */
8
8
uint32_t cpu_mips_get_random (CPUState *env)
10
10
    static uint32_t seed = 0;
11
11
    uint32_t idx;
12
12
    seed = seed * 314159 + 1;
13
 
    idx = (seed >> 16) % (env->tlb->nb_tlb - env->CP0_Wired) + env->CP0_Wired;
 
13
    idx = (seed >> 16) % (env->nb_tlb - env->CP0_Wired) + env->CP0_Wired;
14
14
    return idx;
15
15
}
16
16
 
17
17
/* MIPS R4K timer */
18
18
uint32_t cpu_mips_get_count (CPUState *env)
19
19
{
20
 
    if (env->CP0_Cause & (1 << CP0Ca_DC))
21
 
        return env->CP0_Count;
22
 
    else
23
 
        return env->CP0_Count +
24
 
            (uint32_t)muldiv64(qemu_get_clock(vm_clock),
25
 
                               TIMER_FREQ, ticks_per_sec);
 
20
    return env->CP0_Count +
 
21
        (uint32_t)muldiv64(qemu_get_clock(vm_clock),
 
22
                           100 * 1000 * 1000, ticks_per_sec);
26
23
}
27
24
 
28
 
static void cpu_mips_timer_update(CPUState *env)
 
25
void cpu_mips_store_count (CPUState *env, uint32_t count)
29
26
{
30
27
    uint64_t now, next;
31
 
    uint32_t wait;
 
28
    uint32_t tmp;
 
29
    uint32_t compare = env->CP0_Compare;
32
30
 
 
31
    tmp = count;
 
32
    if (count == compare)
 
33
        tmp++;
33
34
    now = qemu_get_clock(vm_clock);
34
 
    wait = env->CP0_Compare - env->CP0_Count -
35
 
            (uint32_t)muldiv64(now, TIMER_FREQ, ticks_per_sec);
36
 
    next = now + muldiv64(wait, ticks_per_sec, TIMER_FREQ);
 
35
    next = now + muldiv64(compare - tmp, ticks_per_sec, 100 * 1000 * 1000);
 
36
    if (next == now)
 
37
        next++;
 
38
#if 0
 
39
    if (logfile) {
 
40
        fprintf(logfile, "%s: 0x%08" PRIx64 " %08x %08x => 0x%08" PRIx64 "\n",
 
41
                __func__, now, count, compare, next - now);
 
42
    }
 
43
#endif
 
44
    /* Store new count and compare registers */
 
45
    env->CP0_Compare = compare;
 
46
    env->CP0_Count =
 
47
        count - (uint32_t)muldiv64(now, 100 * 1000 * 1000, ticks_per_sec);
 
48
    /* Adjust timer */
37
49
    qemu_mod_timer(env->timer, next);
38
50
}
39
51
 
40
 
void cpu_mips_store_count (CPUState *env, uint32_t count)
 
52
static void cpu_mips_update_count (CPUState *env, uint32_t count)
41
53
{
42
54
    if (env->CP0_Cause & (1 << CP0Ca_DC))
43
 
        env->CP0_Count = count;
44
 
    else {
45
 
        /* Store new count register */
46
 
        env->CP0_Count =
47
 
            count - (uint32_t)muldiv64(qemu_get_clock(vm_clock),
48
 
                                       TIMER_FREQ, ticks_per_sec);
49
 
        /* Update timer timer */
50
 
        cpu_mips_timer_update(env);
51
 
    }
 
55
        return;
 
56
 
 
57
    cpu_mips_store_count(env, count);
52
58
}
53
59
 
54
60
void cpu_mips_store_compare (CPUState *env, uint32_t value)
55
61
{
56
62
    env->CP0_Compare = value;
57
 
    if (!(env->CP0_Cause & (1 << CP0Ca_DC)))
58
 
        cpu_mips_timer_update(env);
59
 
    if (env->insn_flags & ISA_MIPS32R2)
 
63
    cpu_mips_update_count(env, cpu_mips_get_count(env));
 
64
    if ((env->CP0_Config0 & (0x7 << CP0C0_AR)) == (1 << CP0C0_AR))
60
65
        env->CP0_Cause &= ~(1 << CP0Ca_TI);
61
 
    qemu_irq_lower(env->irq[(env->CP0_IntCtl >> CP0IntCtl_IPTI) & 0x7]);
62
 
}
63
 
 
64
 
void cpu_mips_start_count(CPUState *env)
65
 
{
66
 
    cpu_mips_store_count(env, env->CP0_Count);
67
 
}
68
 
 
69
 
void cpu_mips_stop_count(CPUState *env)
70
 
{
71
 
    /* Store the current value */
72
 
    env->CP0_Count += (uint32_t)muldiv64(qemu_get_clock(vm_clock),
73
 
                                         TIMER_FREQ, ticks_per_sec);
 
66
    qemu_irq_lower(env->irq[7]);
74
67
}
75
68
 
76
69
static void mips_timer_cb (void *opaque)
83
76
        fprintf(logfile, "%s\n", __func__);
84
77
    }
85
78
#endif
86
 
 
87
 
    if (env->CP0_Cause & (1 << CP0Ca_DC))
88
 
        return;
89
 
 
90
 
    /* ??? This callback should occur when the counter is exactly equal to
91
 
       the comparator value.  Offset the count by one to avoid immediately
92
 
       retriggering the callback before any virtual time has passed.  */
93
 
    env->CP0_Count++;
94
 
    cpu_mips_timer_update(env);
95
 
    env->CP0_Count--;
96
 
    if (env->insn_flags & ISA_MIPS32R2)
 
79
    cpu_mips_update_count(env, cpu_mips_get_count(env));
 
80
    if ((env->CP0_Config0 & (0x7 << CP0C0_AR)) == (1 << CP0C0_AR))
97
81
        env->CP0_Cause |= 1 << CP0Ca_TI;
98
 
    qemu_irq_raise(env->irq[(env->CP0_IntCtl >> CP0IntCtl_IPTI) & 0x7]);
 
82
    qemu_irq_raise(env->irq[7]);
99
83
}
100
84
 
101
85
void cpu_mips_clock_init (CPUState *env)
102
86
{
103
87
    env->timer = qemu_new_timer(vm_clock, &mips_timer_cb, env);
104
88
    env->CP0_Compare = 0;
105
 
    cpu_mips_store_count(env, 1);
 
89
    cpu_mips_update_count(env, 1);
106
90
}