← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to hw/ptimer.c

  • Committer: pbrook
  • Date: 2006-10-22 00:18:54 UTC
  • Revision ID: git-v1:e6e5906b6e0a81718066ca43aef57515026c6624
ColdFire target.


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

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/ptimer.c
1
 
/*
2
 
 * General purpose implementation of a simple periodic countdown timer.
3
 
 *
4
 
 * Copyright (c) 2007 CodeSourcery.
5
 
 *
6
 
 * This code is licenced under the GNU LGPL.
7
 
 */
8
 
#include "hw.h"
9
 
#include "qemu-timer.h"
10
 
 
11
 
 
12
 
struct ptimer_state
13
 
{
14
 
    int enabled; /* 0 = disabled, 1 = periodic, 2 = oneshot.  */
15
 
    uint64_t limit;
16
 
    uint64_t delta;
17
 
    uint32_t period_frac;
18
 
    int64_t period;
19
 
    int64_t last_event;
20
 
    int64_t next_event;
21
 
    QEMUBH *bh;
22
 
    QEMUTimer *timer;
23
 
};
24
 
 
25
 
/* Use a bottom-half routine to avoid reentrancy issues.  */
26
 
static void ptimer_trigger(ptimer_state *s)
27
 
{
28
 
    if (s->bh) {
29
 
        qemu_bh_schedule(s->bh);
30
 
    }
31
 
}
32
 
 
33
 
static void ptimer_reload(ptimer_state *s)
34
 
{
35
 
    if (s->delta == 0) {
36
 
        ptimer_trigger(s);
37
 
        s->delta = s->limit;
38
 
    }
39
 
    if (s->delta == 0 || s->period == 0) {
40
 
        fprintf(stderr, "Timer with period zero, disabling\n");
41
 
        s->enabled = 0;
42
 
        return;
43
 
    }
44
 
 
45
 
    s->last_event = s->next_event;
46
 
    s->next_event = s->last_event + s->delta * s->period;
47
 
    if (s->period_frac) {
48
 
        s->next_event += ((int64_t)s->period_frac * s->delta) >> 32;
49
 
    }
50
 
    qemu_mod_timer(s->timer, s->next_event);
51
 
}
52
 
 
53
 
static void ptimer_tick(void *opaque)
54
 
{
55
 
    ptimer_state *s = (ptimer_state *)opaque;
56
 
    ptimer_trigger(s);
57
 
    s->delta = 0;
58
 
    if (s->enabled == 2) {
59
 
        s->enabled = 0;
60
 
    } else {
61
 
        ptimer_reload(s);
62
 
    }
63
 
}
64
 
 
65
 
uint64_t ptimer_get_count(ptimer_state *s)
66
 
{
67
 
    int64_t now;
68
 
    uint64_t counter;
69
 
 
70
 
    if (s->enabled) {
71
 
        now = qemu_get_clock(vm_clock);
72
 
        /* Figure out the current counter value.  */
73
 
        if (now - s->next_event > 0
74
 
            || s->period == 0) {
75
 
            /* Prevent timer underflowing if it should already have
76
 
               triggered.  */
77
 
            counter = 0;
78
 
        } else {
79
 
            uint64_t rem;
80
 
            uint64_t div;
81
 
 
82
 
            rem = s->next_event - now;
83
 
            div = s->period;
84
 
            counter = rem / div;
85
 
        }
86
 
    } else {
87
 
        counter = s->delta;
88
 
    }
89
 
    return counter;
90
 
}
91
 
 
92
 
void ptimer_set_count(ptimer_state *s, uint64_t count)
93
 
{
94
 
    s->delta = count;
95
 
    if (s->enabled) {
96
 
        s->next_event = qemu_get_clock(vm_clock);
97
 
        ptimer_reload(s);
98
 
    }
99
 
}
100
 
 
101
 
void ptimer_run(ptimer_state *s, int oneshot)
102
 
{
103
 
    if (s->enabled) {
104
 
        return;
105
 
    }
106
 
    if (s->period == 0) {
107
 
        fprintf(stderr, "Timer with period zero, disabling\n");
108
 
        return;
109
 
    }
110
 
    s->enabled = oneshot ? 2 : 1;
111
 
    s->next_event = qemu_get_clock(vm_clock);
112
 
    ptimer_reload(s);
113
 
}
114
 
 
115
 
/* Pause a timer.  Note that this may cause it to "lose" time, even if it
116
 
   is immediately restarted.  */
117
 
void ptimer_stop(ptimer_state *s)
118
 
{
119
 
    if (!s->enabled)
120
 
        return;
121
 
 
122
 
    s->delta = ptimer_get_count(s);
123
 
    qemu_del_timer(s->timer);
124
 
    s->enabled = 0;
125
 
}
126
 
 
127
 
/* Set counter increment interval in nanoseconds.  */
128
 
void ptimer_set_period(ptimer_state *s, int64_t period)
129
 
{
130
 
    s->period = period;
131
 
    s->period_frac = 0;
132
 
    if (s->enabled) {
133
 
        s->next_event = qemu_get_clock(vm_clock);
134
 
        ptimer_reload(s);
135
 
    }
136
 
}
137
 
 
138
 
/* Set counter frequency in Hz.  */
139
 
void ptimer_set_freq(ptimer_state *s, uint32_t freq)
140
 
{
141
 
    s->period = 1000000000ll / freq;
142
 
    s->period_frac = (1000000000ll << 32) / freq;
143
 
    if (s->enabled) {
144
 
        s->next_event = qemu_get_clock(vm_clock);
145
 
        ptimer_reload(s);
146
 
    }
147
 
}
148
 
 
149
 
/* Set the initial countdown value.  If reload is nonzero then also set
150
 
   count = limit.  */
151
 
void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload)
152
 
{
153
 
    s->limit = limit;
154
 
    if (reload)
155
 
        s->delta = limit;
156
 
    if (s->enabled && reload) {
157
 
        s->next_event = qemu_get_clock(vm_clock);
158
 
        ptimer_reload(s);
159
 
    }
160
 
}
161
 
 
162
 
void qemu_put_ptimer(QEMUFile *f, ptimer_state *s)
163
 
{
164
 
    qemu_put_byte(f, s->enabled);
165
 
    qemu_put_be64s(f, &s->limit);
166
 
    qemu_put_be64s(f, &s->delta);
167
 
    qemu_put_be32s(f, &s->period_frac);
168
 
    qemu_put_be64s(f, &s->period);
169
 
    qemu_put_be64s(f, &s->last_event);
170
 
    qemu_put_be64s(f, &s->next_event);
171
 
    qemu_put_timer(f, s->timer);
172
 
}
173
 
 
174
 
void qemu_get_ptimer(QEMUFile *f, ptimer_state *s)
175
 
{
176
 
    s->enabled = qemu_get_byte(f);
177
 
    qemu_get_be64s(f, &s->limit);
178
 
    qemu_get_be64s(f, &s->delta);
179
 
    qemu_get_be32s(f, &s->period_frac);
180
 
    qemu_get_be64s(f, &s->period);
181
 
    qemu_get_be64s(f, &s->last_event);
182
 
    qemu_get_be64s(f, &s->next_event);
183
 
    qemu_get_timer(f, s->timer);
184
 
}
185
 
 
186
 
ptimer_state *ptimer_init(QEMUBH *bh)
187
 
{
188
 
    ptimer_state *s;
189
 
 
190
 
    s = (ptimer_state *)qemu_mallocz(sizeof(ptimer_state));
191
 
    s->bh = bh;
192
 
    s->timer = qemu_new_timer(vm_clock, ptimer_tick, s);
193
 
    return s;
194
 
}
195