2 * ARM PrimeCell Timer modules.
4 * Copyright (c) 2005-2006 CodeSourcery.
5 * Written by Paul Brook
7 * This code is licensed under the GPL.
10 #include "qemu/osdep.h"
11 #include "hw/sysbus.h"
12 #include "migration/vmstate.h"
13 #include "qemu/timer.h"
15 #include "hw/ptimer.h"
16 #include "hw/qdev-properties.h"
17 #include "qemu/module.h"
19 #include "qom/object.h"
21 /* Common timer implementation. */
23 #define TIMER_CTRL_ONESHOT (1 << 0)
24 #define TIMER_CTRL_32BIT (1 << 1)
25 #define TIMER_CTRL_DIV1 (0 << 2)
26 #define TIMER_CTRL_DIV16 (1 << 2)
27 #define TIMER_CTRL_DIV256 (2 << 2)
28 #define TIMER_CTRL_IE (1 << 5)
29 #define TIMER_CTRL_PERIODIC (1 << 6)
30 #define TIMER_CTRL_ENABLE (1 << 7)
41 /* Check all active timers, and schedule the next timer interrupt. */
43 static void arm_timer_update(arm_timer_state
*s
)
45 /* Update interrupts. */
46 if (s
->int_level
&& (s
->control
& TIMER_CTRL_IE
)) {
47 qemu_irq_raise(s
->irq
);
49 qemu_irq_lower(s
->irq
);
53 static uint32_t arm_timer_read(void *opaque
, hwaddr offset
)
55 arm_timer_state
*s
= (arm_timer_state
*)opaque
;
57 switch (offset
>> 2) {
58 case 0: /* TimerLoad */
59 case 6: /* TimerBGLoad */
61 case 1: /* TimerValue */
62 return ptimer_get_count(s
->timer
);
63 case 2: /* TimerControl */
65 case 4: /* TimerRIS */
67 case 5: /* TimerMIS */
68 if ((s
->control
& TIMER_CTRL_IE
) == 0)
72 qemu_log_mask(LOG_GUEST_ERROR
,
73 "%s: Bad offset %x\n", __func__
, (int)offset
);
79 * Reset the timer limit after settings have changed.
80 * May only be called from inside a ptimer transaction block.
82 static void arm_timer_recalibrate(arm_timer_state
*s
, int reload
)
86 if ((s
->control
& (TIMER_CTRL_PERIODIC
| TIMER_CTRL_ONESHOT
)) == 0) {
88 if (s
->control
& TIMER_CTRL_32BIT
)
96 ptimer_set_limit(s
->timer
, limit
, reload
);
99 static void arm_timer_write(void *opaque
, hwaddr offset
,
102 arm_timer_state
*s
= (arm_timer_state
*)opaque
;
105 switch (offset
>> 2) {
106 case 0: /* TimerLoad */
108 ptimer_transaction_begin(s
->timer
);
109 arm_timer_recalibrate(s
, 1);
110 ptimer_transaction_commit(s
->timer
);
112 case 1: /* TimerValue */
113 /* ??? Linux seems to want to write to this readonly register.
116 case 2: /* TimerControl */
117 ptimer_transaction_begin(s
->timer
);
118 if (s
->control
& TIMER_CTRL_ENABLE
) {
119 /* Pause the timer if it is running. This may cause some
120 inaccuracy dure to rounding, but avoids a whole lot of other
122 ptimer_stop(s
->timer
);
126 /* ??? Need to recalculate expiry time after changing divisor. */
127 switch ((value
>> 2) & 3) {
128 case 1: freq
>>= 4; break;
129 case 2: freq
>>= 8; break;
131 arm_timer_recalibrate(s
, s
->control
& TIMER_CTRL_ENABLE
);
132 ptimer_set_freq(s
->timer
, freq
);
133 if (s
->control
& TIMER_CTRL_ENABLE
) {
134 /* Restart the timer if still enabled. */
135 ptimer_run(s
->timer
, (s
->control
& TIMER_CTRL_ONESHOT
) != 0);
137 ptimer_transaction_commit(s
->timer
);
139 case 3: /* TimerIntClr */
142 case 6: /* TimerBGLoad */
144 ptimer_transaction_begin(s
->timer
);
145 arm_timer_recalibrate(s
, 0);
146 ptimer_transaction_commit(s
->timer
);
149 qemu_log_mask(LOG_GUEST_ERROR
,
150 "%s: Bad offset %x\n", __func__
, (int)offset
);
155 static void arm_timer_tick(void *opaque
)
157 arm_timer_state
*s
= (arm_timer_state
*)opaque
;
162 static const VMStateDescription vmstate_arm_timer
= {
165 .minimum_version_id
= 1,
166 .fields
= (VMStateField
[]) {
167 VMSTATE_UINT32(control
, arm_timer_state
),
168 VMSTATE_UINT32(limit
, arm_timer_state
),
169 VMSTATE_INT32(int_level
, arm_timer_state
),
170 VMSTATE_PTIMER(timer
, arm_timer_state
),
171 VMSTATE_END_OF_LIST()
175 static arm_timer_state
*arm_timer_init(uint32_t freq
)
179 s
= (arm_timer_state
*)g_malloc0(sizeof(arm_timer_state
));
181 s
->control
= TIMER_CTRL_IE
;
183 s
->timer
= ptimer_init(arm_timer_tick
, s
, PTIMER_POLICY_DEFAULT
);
184 vmstate_register(NULL
, VMSTATE_INSTANCE_ID_ANY
, &vmstate_arm_timer
, s
);
188 /* ARM PrimeCell SP804 dual timer module.
190 * http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0271d/index.html
193 #define TYPE_SP804 "sp804"
194 OBJECT_DECLARE_SIMPLE_TYPE(SP804State
, SP804
)
197 SysBusDevice parent_obj
;
200 arm_timer_state
*timer
[2];
201 uint32_t freq0
, freq1
;
206 static const uint8_t sp804_ids
[] = {
210 0xd, 0xf0, 0x05, 0xb1
213 /* Merge the IRQs from the two component devices. */
214 static void sp804_set_irq(void *opaque
, int irq
, int level
)
216 SP804State
*s
= (SP804State
*)opaque
;
218 s
->level
[irq
] = level
;
219 qemu_set_irq(s
->irq
, s
->level
[0] || s
->level
[1]);
222 static uint64_t sp804_read(void *opaque
, hwaddr offset
,
225 SP804State
*s
= (SP804State
*)opaque
;
228 return arm_timer_read(s
->timer
[0], offset
);
231 return arm_timer_read(s
->timer
[1], offset
- 0x20);
235 if (offset
>= 0xfe0 && offset
<= 0xffc) {
236 return sp804_ids
[(offset
- 0xfe0) >> 2];
240 /* Integration Test control registers, which we won't support */
241 case 0xf00: /* TimerITCR */
242 case 0xf04: /* TimerITOP (strictly write only but..) */
243 qemu_log_mask(LOG_UNIMP
,
244 "%s: integration test registers unimplemented\n",
249 qemu_log_mask(LOG_GUEST_ERROR
,
250 "%s: Bad offset %x\n", __func__
, (int)offset
);
254 static void sp804_write(void *opaque
, hwaddr offset
,
255 uint64_t value
, unsigned size
)
257 SP804State
*s
= (SP804State
*)opaque
;
260 arm_timer_write(s
->timer
[0], offset
, value
);
265 arm_timer_write(s
->timer
[1], offset
- 0x20, value
);
269 /* Technically we could be writing to the Test Registers, but not likely */
270 qemu_log_mask(LOG_GUEST_ERROR
, "%s: Bad offset %x\n",
271 __func__
, (int)offset
);
274 static const MemoryRegionOps sp804_ops
= {
276 .write
= sp804_write
,
277 .endianness
= DEVICE_NATIVE_ENDIAN
,
280 static const VMStateDescription vmstate_sp804
= {
283 .minimum_version_id
= 1,
284 .fields
= (VMStateField
[]) {
285 VMSTATE_INT32_ARRAY(level
, SP804State
, 2),
286 VMSTATE_END_OF_LIST()
290 static void sp804_init(Object
*obj
)
292 SP804State
*s
= SP804(obj
);
293 SysBusDevice
*sbd
= SYS_BUS_DEVICE(obj
);
295 sysbus_init_irq(sbd
, &s
->irq
);
296 memory_region_init_io(&s
->iomem
, obj
, &sp804_ops
, s
,
298 sysbus_init_mmio(sbd
, &s
->iomem
);
301 static void sp804_realize(DeviceState
*dev
, Error
**errp
)
303 SP804State
*s
= SP804(dev
);
305 s
->timer
[0] = arm_timer_init(s
->freq0
);
306 s
->timer
[1] = arm_timer_init(s
->freq1
);
307 s
->timer
[0]->irq
= qemu_allocate_irq(sp804_set_irq
, s
, 0);
308 s
->timer
[1]->irq
= qemu_allocate_irq(sp804_set_irq
, s
, 1);
311 /* Integrator/CP timer module. */
313 #define TYPE_INTEGRATOR_PIT "integrator_pit"
314 OBJECT_DECLARE_SIMPLE_TYPE(icp_pit_state
, INTEGRATOR_PIT
)
316 struct icp_pit_state
{
317 SysBusDevice parent_obj
;
320 arm_timer_state
*timer
[3];
323 static uint64_t icp_pit_read(void *opaque
, hwaddr offset
,
326 icp_pit_state
*s
= (icp_pit_state
*)opaque
;
329 /* ??? Don't know the PrimeCell ID for this device. */
332 qemu_log_mask(LOG_GUEST_ERROR
, "%s: Bad timer %d\n", __func__
, n
);
336 return arm_timer_read(s
->timer
[n
], offset
& 0xff);
339 static void icp_pit_write(void *opaque
, hwaddr offset
,
340 uint64_t value
, unsigned size
)
342 icp_pit_state
*s
= (icp_pit_state
*)opaque
;
347 qemu_log_mask(LOG_GUEST_ERROR
, "%s: Bad timer %d\n", __func__
, n
);
351 arm_timer_write(s
->timer
[n
], offset
& 0xff, value
);
354 static const MemoryRegionOps icp_pit_ops
= {
355 .read
= icp_pit_read
,
356 .write
= icp_pit_write
,
357 .endianness
= DEVICE_NATIVE_ENDIAN
,
360 static void icp_pit_init(Object
*obj
)
362 icp_pit_state
*s
= INTEGRATOR_PIT(obj
);
363 SysBusDevice
*dev
= SYS_BUS_DEVICE(obj
);
365 /* Timer 0 runs at the system clock speed (40MHz). */
366 s
->timer
[0] = arm_timer_init(40000000);
367 /* The other two timers run at 1MHz. */
368 s
->timer
[1] = arm_timer_init(1000000);
369 s
->timer
[2] = arm_timer_init(1000000);
371 sysbus_init_irq(dev
, &s
->timer
[0]->irq
);
372 sysbus_init_irq(dev
, &s
->timer
[1]->irq
);
373 sysbus_init_irq(dev
, &s
->timer
[2]->irq
);
375 memory_region_init_io(&s
->iomem
, obj
, &icp_pit_ops
, s
,
377 sysbus_init_mmio(dev
, &s
->iomem
);
378 /* This device has no state to save/restore. The component timers will
382 static const TypeInfo icp_pit_info
= {
383 .name
= TYPE_INTEGRATOR_PIT
,
384 .parent
= TYPE_SYS_BUS_DEVICE
,
385 .instance_size
= sizeof(icp_pit_state
),
386 .instance_init
= icp_pit_init
,
389 static Property sp804_properties
[] = {
390 DEFINE_PROP_UINT32("freq0", SP804State
, freq0
, 1000000),
391 DEFINE_PROP_UINT32("freq1", SP804State
, freq1
, 1000000),
392 DEFINE_PROP_END_OF_LIST(),
395 static void sp804_class_init(ObjectClass
*klass
, void *data
)
397 DeviceClass
*k
= DEVICE_CLASS(klass
);
399 k
->realize
= sp804_realize
;
400 device_class_set_props(k
, sp804_properties
);
401 k
->vmsd
= &vmstate_sp804
;
404 static const TypeInfo sp804_info
= {
406 .parent
= TYPE_SYS_BUS_DEVICE
,
407 .instance_size
= sizeof(SP804State
),
408 .instance_init
= sp804_init
,
409 .class_init
= sp804_class_init
,
412 static void arm_timer_register_types(void)
414 type_register_static(&icp_pit_info
);
415 type_register_static(&sp804_info
);
418 type_init(arm_timer_register_types
)