2 * Intel XScale PXA255/270 OS Timers.
4 * Copyright (c) 2006 Openedhand Ltd.
5 * Copyright (c) 2006 Thorsten Zitterell
7 * This code is licensed under the GPL.
10 #include "qemu/osdep.h"
12 #include "qemu/timer.h"
13 #include "sysemu/sysemu.h"
14 #include "hw/arm/pxa.h"
15 #include "hw/sysbus.h"
29 #define OSCR 0x10 /* OS Timer Count */
38 #define OSSR 0x14 /* Timer status register */
40 #define OIER 0x1c /* Interrupt enable register 3-0 to E3-E0 */
41 #define OMCR4 0xc0 /* OS Match Control registers */
51 #define PXA25X_FREQ 3686400 /* 3.6864 MHz */
52 #define PXA27X_FREQ 3250000 /* 3.25 MHz */
54 static int pxa2xx_timer4_freq
[8] = {
60 /* [5] is the "Externally supplied clock". Assign if necessary. */
64 #define TYPE_PXA2XX_TIMER "pxa2xx-timer"
65 #define PXA2XX_TIMER(obj) \
66 OBJECT_CHECK(PXA2xxTimerInfo, (obj), TYPE_PXA2XX_TIMER)
68 typedef struct PXA2xxTimerInfo PXA2xxTimerInfo
;
75 PXA2xxTimerInfo
*info
;
87 struct PXA2xxTimerInfo
{
88 SysBusDevice parent_obj
;
97 PXA2xxTimer0 timer
[4];
107 #define PXA2XX_TIMER_HAVE_TM4 0
109 static inline int pxa2xx_timer_has_tm4(PXA2xxTimerInfo
*s
)
111 return s
->flags
& (1 << PXA2XX_TIMER_HAVE_TM4
);
114 static void pxa2xx_timer_update(void *opaque
, uint64_t now_qemu
)
116 PXA2xxTimerInfo
*s
= (PXA2xxTimerInfo
*) opaque
;
122 muldiv64(now_qemu
- s
->lastload
, s
->freq
, get_ticks_per_sec());
124 for (i
= 0; i
< 4; i
++) {
125 new_qemu
= now_qemu
+ muldiv64((uint32_t) (s
->timer
[i
].value
- now_vm
),
126 get_ticks_per_sec(), s
->freq
);
127 timer_mod(s
->timer
[i
].qtimer
, new_qemu
);
131 static void pxa2xx_timer_update4(void *opaque
, uint64_t now_qemu
, int n
)
133 PXA2xxTimerInfo
*s
= (PXA2xxTimerInfo
*) opaque
;
136 static const int counters
[8] = { 0, 0, 0, 0, 4, 4, 6, 6 };
139 if (s
->tm4
[n
].control
& (1 << 7))
142 counter
= counters
[n
];
144 if (!s
->tm4
[counter
].freq
) {
145 timer_del(s
->tm4
[n
].tm
.qtimer
);
149 now_vm
= s
->tm4
[counter
].clock
+ muldiv64(now_qemu
-
150 s
->tm4
[counter
].lastload
,
151 s
->tm4
[counter
].freq
, get_ticks_per_sec());
153 new_qemu
= now_qemu
+ muldiv64((uint32_t) (s
->tm4
[n
].tm
.value
- now_vm
),
154 get_ticks_per_sec(), s
->tm4
[counter
].freq
);
155 timer_mod(s
->tm4
[n
].tm
.qtimer
, new_qemu
);
158 static uint64_t pxa2xx_timer_read(void *opaque
, hwaddr offset
,
161 PXA2xxTimerInfo
*s
= (PXA2xxTimerInfo
*) opaque
;
172 return s
->timer
[tm
].value
;
188 if (!pxa2xx_timer_has_tm4(s
))
190 return s
->tm4
[tm
].tm
.value
;
192 return s
->clock
+ muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) -
193 s
->lastload
, s
->freq
, get_ticks_per_sec());
209 if (!pxa2xx_timer_has_tm4(s
))
212 if ((tm
== 9 - 4 || tm
== 11 - 4) && (s
->tm4
[tm
].control
& (1 << 9))) {
213 if (s
->tm4
[tm
- 1].freq
)
214 s
->snapshot
= s
->tm4
[tm
- 1].clock
+ muldiv64(
215 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) -
216 s
->tm4
[tm
- 1].lastload
,
217 s
->tm4
[tm
- 1].freq
, get_ticks_per_sec());
219 s
->snapshot
= s
->tm4
[tm
- 1].clock
;
222 if (!s
->tm4
[tm
].freq
)
223 return s
->tm4
[tm
].clock
;
224 return s
->tm4
[tm
].clock
+ muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) -
225 s
->tm4
[tm
].lastload
, s
->tm4
[tm
].freq
, get_ticks_per_sec());
227 return s
->irq_enabled
;
228 case OSSR
: /* Status register */
247 if (!pxa2xx_timer_has_tm4(s
))
249 return s
->tm4
[tm
].control
;
254 hw_error("pxa2xx_timer_read: Bad offset " REG_FMT
"\n", offset
);
260 static void pxa2xx_timer_write(void *opaque
, hwaddr offset
,
261 uint64_t value
, unsigned size
)
264 PXA2xxTimerInfo
*s
= (PXA2xxTimerInfo
*) opaque
;
274 s
->timer
[tm
].value
= value
;
275 pxa2xx_timer_update(s
, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
));
292 if (!pxa2xx_timer_has_tm4(s
))
294 s
->tm4
[tm
].tm
.value
= value
;
295 pxa2xx_timer_update4(s
, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
), tm
);
298 s
->oldclock
= s
->clock
;
299 s
->lastload
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
301 pxa2xx_timer_update(s
, s
->lastload
);
318 if (!pxa2xx_timer_has_tm4(s
))
320 s
->tm4
[tm
].oldclock
= s
->tm4
[tm
].clock
;
321 s
->tm4
[tm
].lastload
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
322 s
->tm4
[tm
].clock
= value
;
323 pxa2xx_timer_update4(s
, s
->tm4
[tm
].lastload
, tm
);
326 s
->irq_enabled
= value
& 0xfff;
328 case OSSR
: /* Status register */
331 for (i
= 0; i
< 4; i
++, value
>>= 1)
333 qemu_irq_lower(s
->timer
[i
].irq
);
334 if (pxa2xx_timer_has_tm4(s
) && !(s
->events
& 0xff0) && value
)
335 qemu_irq_lower(s
->irq4
);
337 case OWER
: /* XXX: Reset on OSMR3 match? */
347 if (!pxa2xx_timer_has_tm4(s
))
349 s
->tm4
[tm
].control
= value
& 0x0ff;
350 /* XXX Stop if running (shouldn't happen) */
351 if ((value
& (1 << 7)) || tm
== 0)
352 s
->tm4
[tm
].freq
= pxa2xx_timer4_freq
[value
& 7];
355 pxa2xx_timer_update4(s
, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
), tm
);
365 if (!pxa2xx_timer_has_tm4(s
))
367 s
->tm4
[tm
].control
= value
& 0x3ff;
368 /* XXX Stop if running (shouldn't happen) */
369 if ((value
& (1 << 7)) || !(tm
& 1))
371 pxa2xx_timer4_freq
[(value
& (1 << 8)) ? 0 : (value
& 7)];
374 pxa2xx_timer_update4(s
, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
), tm
);
379 hw_error("pxa2xx_timer_write: Bad offset " REG_FMT
"\n", offset
);
383 static const MemoryRegionOps pxa2xx_timer_ops
= {
384 .read
= pxa2xx_timer_read
,
385 .write
= pxa2xx_timer_write
,
386 .endianness
= DEVICE_NATIVE_ENDIAN
,
389 static void pxa2xx_timer_tick(void *opaque
)
391 PXA2xxTimer0
*t
= (PXA2xxTimer0
*) opaque
;
392 PXA2xxTimerInfo
*i
= t
->info
;
394 if (i
->irq_enabled
& (1 << t
->num
)) {
395 i
->events
|= 1 << t
->num
;
396 qemu_irq_raise(t
->irq
);
402 qemu_system_reset_request();
406 static void pxa2xx_timer_tick4(void *opaque
)
408 PXA2xxTimer4
*t
= (PXA2xxTimer4
*) opaque
;
409 PXA2xxTimerInfo
*i
= (PXA2xxTimerInfo
*) t
->tm
.info
;
411 pxa2xx_timer_tick(&t
->tm
);
412 if (t
->control
& (1 << 3))
414 if (t
->control
& (1 << 6))
415 pxa2xx_timer_update4(i
, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
), t
->tm
.num
- 4);
416 if (i
->events
& 0xff0)
417 qemu_irq_raise(i
->irq4
);
420 static int pxa25x_timer_post_load(void *opaque
, int version_id
)
422 PXA2xxTimerInfo
*s
= (PXA2xxTimerInfo
*) opaque
;
426 now
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
427 pxa2xx_timer_update(s
, now
);
429 if (pxa2xx_timer_has_tm4(s
))
430 for (i
= 0; i
< 8; i
++)
431 pxa2xx_timer_update4(s
, now
, i
);
436 static void pxa2xx_timer_init(Object
*obj
)
438 PXA2xxTimerInfo
*s
= PXA2XX_TIMER(obj
);
439 SysBusDevice
*dev
= SYS_BUS_DEVICE(obj
);
444 s
->lastload
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
447 memory_region_init_io(&s
->iomem
, obj
, &pxa2xx_timer_ops
, s
,
448 "pxa2xx-timer", 0x00001000);
449 sysbus_init_mmio(dev
, &s
->iomem
);
452 static void pxa2xx_timer_realize(DeviceState
*dev
, Error
**errp
)
454 PXA2xxTimerInfo
*s
= PXA2XX_TIMER(dev
);
455 SysBusDevice
*sbd
= SYS_BUS_DEVICE(dev
);
458 for (i
= 0; i
< 4; i
++) {
459 s
->timer
[i
].value
= 0;
460 sysbus_init_irq(sbd
, &s
->timer
[i
].irq
);
461 s
->timer
[i
].info
= s
;
463 s
->timer
[i
].qtimer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
,
464 pxa2xx_timer_tick
, &s
->timer
[i
]);
467 if (s
->flags
& (1 << PXA2XX_TIMER_HAVE_TM4
)) {
468 sysbus_init_irq(sbd
, &s
->irq4
);
470 for (i
= 0; i
< 8; i
++) {
471 s
->tm4
[i
].tm
.value
= 0;
472 s
->tm4
[i
].tm
.info
= s
;
473 s
->tm4
[i
].tm
.num
= i
+ 4;
475 s
->tm4
[i
].control
= 0x0;
476 s
->tm4
[i
].tm
.qtimer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
,
477 pxa2xx_timer_tick4
, &s
->tm4
[i
]);
482 static const VMStateDescription vmstate_pxa2xx_timer0_regs
= {
483 .name
= "pxa2xx_timer0",
485 .minimum_version_id
= 2,
486 .fields
= (VMStateField
[]) {
487 VMSTATE_UINT32(value
, PXA2xxTimer0
),
488 VMSTATE_END_OF_LIST(),
492 static const VMStateDescription vmstate_pxa2xx_timer4_regs
= {
493 .name
= "pxa2xx_timer4",
495 .minimum_version_id
= 1,
496 .fields
= (VMStateField
[]) {
497 VMSTATE_STRUCT(tm
, PXA2xxTimer4
, 1,
498 vmstate_pxa2xx_timer0_regs
, PXA2xxTimer0
),
499 VMSTATE_INT32(oldclock
, PXA2xxTimer4
),
500 VMSTATE_INT32(clock
, PXA2xxTimer4
),
501 VMSTATE_UINT64(lastload
, PXA2xxTimer4
),
502 VMSTATE_UINT32(freq
, PXA2xxTimer4
),
503 VMSTATE_UINT32(control
, PXA2xxTimer4
),
504 VMSTATE_END_OF_LIST(),
508 static bool pxa2xx_timer_has_tm4_test(void *opaque
, int version_id
)
510 return pxa2xx_timer_has_tm4(opaque
);
513 static const VMStateDescription vmstate_pxa2xx_timer_regs
= {
514 .name
= "pxa2xx_timer",
516 .minimum_version_id
= 1,
517 .post_load
= pxa25x_timer_post_load
,
518 .fields
= (VMStateField
[]) {
519 VMSTATE_INT32(clock
, PXA2xxTimerInfo
),
520 VMSTATE_INT32(oldclock
, PXA2xxTimerInfo
),
521 VMSTATE_UINT64(lastload
, PXA2xxTimerInfo
),
522 VMSTATE_STRUCT_ARRAY(timer
, PXA2xxTimerInfo
, 4, 1,
523 vmstate_pxa2xx_timer0_regs
, PXA2xxTimer0
),
524 VMSTATE_UINT32(events
, PXA2xxTimerInfo
),
525 VMSTATE_UINT32(irq_enabled
, PXA2xxTimerInfo
),
526 VMSTATE_UINT32(reset3
, PXA2xxTimerInfo
),
527 VMSTATE_UINT32(snapshot
, PXA2xxTimerInfo
),
528 VMSTATE_STRUCT_ARRAY_TEST(tm4
, PXA2xxTimerInfo
, 8,
529 pxa2xx_timer_has_tm4_test
, 0,
530 vmstate_pxa2xx_timer4_regs
, PXA2xxTimer4
),
531 VMSTATE_END_OF_LIST(),
535 static Property pxa25x_timer_dev_properties
[] = {
536 DEFINE_PROP_UINT32("freq", PXA2xxTimerInfo
, freq
, PXA25X_FREQ
),
537 DEFINE_PROP_BIT("tm4", PXA2xxTimerInfo
, flags
,
538 PXA2XX_TIMER_HAVE_TM4
, false),
539 DEFINE_PROP_END_OF_LIST(),
542 static void pxa25x_timer_dev_class_init(ObjectClass
*klass
, void *data
)
544 DeviceClass
*dc
= DEVICE_CLASS(klass
);
546 dc
->desc
= "PXA25x timer";
547 dc
->props
= pxa25x_timer_dev_properties
;
550 static const TypeInfo pxa25x_timer_dev_info
= {
551 .name
= "pxa25x-timer",
552 .parent
= TYPE_PXA2XX_TIMER
,
553 .instance_size
= sizeof(PXA2xxTimerInfo
),
554 .class_init
= pxa25x_timer_dev_class_init
,
557 static Property pxa27x_timer_dev_properties
[] = {
558 DEFINE_PROP_UINT32("freq", PXA2xxTimerInfo
, freq
, PXA27X_FREQ
),
559 DEFINE_PROP_BIT("tm4", PXA2xxTimerInfo
, flags
,
560 PXA2XX_TIMER_HAVE_TM4
, true),
561 DEFINE_PROP_END_OF_LIST(),
564 static void pxa27x_timer_dev_class_init(ObjectClass
*klass
, void *data
)
566 DeviceClass
*dc
= DEVICE_CLASS(klass
);
568 dc
->desc
= "PXA27x timer";
569 dc
->props
= pxa27x_timer_dev_properties
;
572 static const TypeInfo pxa27x_timer_dev_info
= {
573 .name
= "pxa27x-timer",
574 .parent
= TYPE_PXA2XX_TIMER
,
575 .instance_size
= sizeof(PXA2xxTimerInfo
),
576 .class_init
= pxa27x_timer_dev_class_init
,
579 static void pxa2xx_timer_class_init(ObjectClass
*oc
, void *data
)
581 DeviceClass
*dc
= DEVICE_CLASS(oc
);
583 dc
->realize
= pxa2xx_timer_realize
;
584 dc
->vmsd
= &vmstate_pxa2xx_timer_regs
;
587 static const TypeInfo pxa2xx_timer_type_info
= {
588 .name
= TYPE_PXA2XX_TIMER
,
589 .parent
= TYPE_SYS_BUS_DEVICE
,
590 .instance_size
= sizeof(PXA2xxTimerInfo
),
591 .instance_init
= pxa2xx_timer_init
,
593 .class_init
= pxa2xx_timer_class_init
,
596 static void pxa2xx_timer_register_types(void)
598 type_register_static(&pxa2xx_timer_type_info
);
599 type_register_static(&pxa25x_timer_dev_info
);
600 type_register_static(&pxa27x_timer_dev_info
);
603 type_init(pxa2xx_timer_register_types
)