2 * QEMU model of the Xilinx timer block.
4 * Copyright (c) 2009 Edgar E. Iglesias.
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu/osdep.h"
26 #include "hw/sysbus.h"
28 #include "hw/ptimer.h"
30 #include "qemu/main-loop.h"
31 #include "qemu/module.h"
40 #define TCSR_MDT (1<<0)
41 #define TCSR_UDT (1<<1)
42 #define TCSR_GENT (1<<2)
43 #define TCSR_CAPT (1<<3)
44 #define TCSR_ARHT (1<<4)
45 #define TCSR_LOAD (1<<5)
46 #define TCSR_ENIT (1<<6)
47 #define TCSR_ENT (1<<7)
48 #define TCSR_TINT (1<<8)
49 #define TCSR_PWMA (1<<9)
50 #define TCSR_ENALL (1<<10)
57 int nr
; /* for debug. */
59 unsigned long timer_div
;
64 #define TYPE_XILINX_TIMER "xlnx.xps-timer"
65 #define XILINX_TIMER(obj) \
66 OBJECT_CHECK(struct timerblock, (obj), TYPE_XILINX_TIMER)
70 SysBusDevice parent_obj
;
74 uint8_t one_timer_only
;
76 struct xlx_timer
*timers
;
79 static inline unsigned int num_timers(struct timerblock
*t
)
81 return 2 - t
->one_timer_only
;
84 static inline unsigned int timer_from_addr(hwaddr addr
)
86 /* Timers get a 4x32bit control reg area each. */
90 static void timer_update_irq(struct timerblock
*t
)
92 unsigned int i
, irq
= 0;
95 for (i
= 0; i
< num_timers(t
); i
++) {
96 csr
= t
->timers
[i
].regs
[R_TCSR
];
97 irq
|= (csr
& TCSR_TINT
) && (csr
& TCSR_ENIT
);
100 /* All timers within the same slave share a single IRQ line. */
101 qemu_set_irq(t
->irq
, !!irq
);
105 timer_read(void *opaque
, hwaddr addr
, unsigned int size
)
107 struct timerblock
*t
= opaque
;
108 struct xlx_timer
*xt
;
113 timer
= timer_from_addr(addr
);
114 xt
= &t
->timers
[timer
];
115 /* Further decoding to address a specific timers reg. */
120 r
= ptimer_get_count(xt
->ptimer
);
121 if (!(xt
->regs
[R_TCSR
] & TCSR_UDT
))
123 D(qemu_log("xlx_timer t=%d read counter=%x udt=%d\n",
124 timer
, r
, xt
->regs
[R_TCSR
] & TCSR_UDT
));
127 if (addr
< ARRAY_SIZE(xt
->regs
))
132 D(fprintf(stderr
, "%s timer=%d %x=%x\n", __func__
, timer
, addr
* 4, r
));
136 static void timer_enable(struct xlx_timer
*xt
)
140 D(fprintf(stderr
, "%s timer=%d down=%d\n", __func__
,
141 xt
->nr
, xt
->regs
[R_TCSR
] & TCSR_UDT
));
143 ptimer_stop(xt
->ptimer
);
145 if (xt
->regs
[R_TCSR
] & TCSR_UDT
)
146 count
= xt
->regs
[R_TLR
];
148 count
= ~0 - xt
->regs
[R_TLR
];
149 ptimer_set_limit(xt
->ptimer
, count
, 1);
150 ptimer_run(xt
->ptimer
, 1);
154 timer_write(void *opaque
, hwaddr addr
,
155 uint64_t val64
, unsigned int size
)
157 struct timerblock
*t
= opaque
;
158 struct xlx_timer
*xt
;
160 uint32_t value
= val64
;
163 timer
= timer_from_addr(addr
);
164 xt
= &t
->timers
[timer
];
165 D(fprintf(stderr
, "%s addr=%x val=%x (timer=%d off=%d)\n",
166 __func__
, addr
* 4, value
, timer
, addr
& 3));
167 /* Further decoding to address a specific timers reg. */
172 if (value
& TCSR_TINT
)
175 xt
->regs
[addr
] = value
& 0x7ff;
176 if (value
& TCSR_ENT
)
181 if (addr
< ARRAY_SIZE(xt
->regs
))
182 xt
->regs
[addr
] = value
;
188 static const MemoryRegionOps timer_ops
= {
190 .write
= timer_write
,
191 .endianness
= DEVICE_NATIVE_ENDIAN
,
193 .min_access_size
= 4,
198 static void timer_hit(void *opaque
)
200 struct xlx_timer
*xt
= opaque
;
201 struct timerblock
*t
= xt
->parent
;
202 D(fprintf(stderr
, "%s %d\n", __func__
, xt
->nr
));
203 xt
->regs
[R_TCSR
] |= TCSR_TINT
;
205 if (xt
->regs
[R_TCSR
] & TCSR_ARHT
)
210 static void xilinx_timer_realize(DeviceState
*dev
, Error
**errp
)
212 struct timerblock
*t
= XILINX_TIMER(dev
);
215 /* Init all the ptimers. */
216 t
->timers
= g_malloc0(sizeof t
->timers
[0] * num_timers(t
));
217 for (i
= 0; i
< num_timers(t
); i
++) {
218 struct xlx_timer
*xt
= &t
->timers
[i
];
222 xt
->bh
= qemu_bh_new(timer_hit
, xt
);
223 xt
->ptimer
= ptimer_init(xt
->bh
, PTIMER_POLICY_DEFAULT
);
224 ptimer_set_freq(xt
->ptimer
, t
->freq_hz
);
227 memory_region_init_io(&t
->mmio
, OBJECT(t
), &timer_ops
, t
, "xlnx.xps-timer",
228 R_MAX
* 4 * num_timers(t
));
229 sysbus_init_mmio(SYS_BUS_DEVICE(dev
), &t
->mmio
);
232 static void xilinx_timer_init(Object
*obj
)
234 struct timerblock
*t
= XILINX_TIMER(obj
);
236 /* All timers share a single irq line. */
237 sysbus_init_irq(SYS_BUS_DEVICE(obj
), &t
->irq
);
240 static Property xilinx_timer_properties
[] = {
241 DEFINE_PROP_UINT32("clock-frequency", struct timerblock
, freq_hz
,
243 DEFINE_PROP_UINT8("one-timer-only", struct timerblock
, one_timer_only
, 0),
244 DEFINE_PROP_END_OF_LIST(),
247 static void xilinx_timer_class_init(ObjectClass
*klass
, void *data
)
249 DeviceClass
*dc
= DEVICE_CLASS(klass
);
251 dc
->realize
= xilinx_timer_realize
;
252 dc
->props
= xilinx_timer_properties
;
255 static const TypeInfo xilinx_timer_info
= {
256 .name
= TYPE_XILINX_TIMER
,
257 .parent
= TYPE_SYS_BUS_DEVICE
,
258 .instance_size
= sizeof(struct timerblock
),
259 .instance_init
= xilinx_timer_init
,
260 .class_init
= xilinx_timer_class_init
,
263 static void xilinx_timer_register_types(void)
265 type_register_static(&xilinx_timer_info
);
268 type_init(xilinx_timer_register_types
)