2 * QEMU model of the Milkymist System Controller.
4 * Copyright (c) 2010-2012 Michael Walle <michael@walle.cc>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
20 * Specification available at:
21 * http://milkymist.walle.cc/socdoc/sysctl.pdf
24 #include "qemu/osdep.h"
26 #include "hw/sysbus.h"
27 #include "migration/vmstate.h"
29 #include "qemu/timer.h"
30 #include "sysemu/runstate.h"
31 #include "hw/ptimer.h"
32 #include "hw/qdev-properties.h"
33 #include "qemu/error-report.h"
34 #include "qemu/module.h"
35 #include "qom/object.h"
39 CTRL_AUTORESTART
= (1<<1),
57 R_DBG_SCRATCHPAD
= 20,
65 #define TYPE_MILKYMIST_SYSCTL "milkymist-sysctl"
66 OBJECT_DECLARE_SIMPLE_TYPE(MilkymistSysctlState
, MILKYMIST_SYSCTL
)
68 struct MilkymistSysctlState
{
69 SysBusDevice parent_obj
;
71 MemoryRegion regs_region
;
73 ptimer_state
*ptimer0
;
74 ptimer_state
*ptimer1
;
77 uint32_t capabilities
;
88 static void sysctl_icap_write(MilkymistSysctlState
*s
, uint32_t value
)
90 trace_milkymist_sysctl_icap_write(value
);
91 switch (value
& 0xffff) {
93 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN
);
98 static uint64_t sysctl_read(void *opaque
, hwaddr addr
,
101 MilkymistSysctlState
*s
= opaque
;
106 case R_TIMER0_COUNTER
:
107 r
= (uint32_t)ptimer_get_count(s
->ptimer0
);
108 /* milkymist timer counts up */
109 r
= s
->regs
[R_TIMER0_COMPARE
] - r
;
111 case R_TIMER1_COUNTER
:
112 r
= (uint32_t)ptimer_get_count(s
->ptimer1
);
113 /* milkymist timer counts up */
114 r
= s
->regs
[R_TIMER1_COMPARE
] - r
;
119 case R_TIMER0_CONTROL
:
120 case R_TIMER0_COMPARE
:
121 case R_TIMER1_CONTROL
:
122 case R_TIMER1_COMPARE
:
124 case R_DBG_SCRATCHPAD
:
125 case R_DBG_WRITE_LOCK
:
126 case R_CLK_FREQUENCY
:
133 error_report("milkymist_sysctl: read access to unknown register 0x"
134 TARGET_FMT_plx
, addr
<< 2);
138 trace_milkymist_sysctl_memory_read(addr
<< 2, r
);
143 static void sysctl_write(void *opaque
, hwaddr addr
, uint64_t value
,
146 MilkymistSysctlState
*s
= opaque
;
148 trace_milkymist_sysctl_memory_write(addr
, value
);
154 case R_TIMER0_COUNTER
:
155 case R_TIMER1_COUNTER
:
156 case R_DBG_SCRATCHPAD
:
157 s
->regs
[addr
] = value
;
159 case R_TIMER0_COMPARE
:
160 ptimer_transaction_begin(s
->ptimer0
);
161 ptimer_set_limit(s
->ptimer0
, value
, 0);
162 s
->regs
[addr
] = value
;
163 ptimer_transaction_commit(s
->ptimer0
);
165 case R_TIMER1_COMPARE
:
166 ptimer_transaction_begin(s
->ptimer1
);
167 ptimer_set_limit(s
->ptimer1
, value
, 0);
168 s
->regs
[addr
] = value
;
169 ptimer_transaction_commit(s
->ptimer1
);
171 case R_TIMER0_CONTROL
:
172 ptimer_transaction_begin(s
->ptimer0
);
173 s
->regs
[addr
] = value
;
174 if (s
->regs
[R_TIMER0_CONTROL
] & CTRL_ENABLE
) {
175 trace_milkymist_sysctl_start_timer0();
176 ptimer_set_count(s
->ptimer0
,
177 s
->regs
[R_TIMER0_COMPARE
] - s
->regs
[R_TIMER0_COUNTER
]);
178 ptimer_run(s
->ptimer0
, 0);
180 trace_milkymist_sysctl_stop_timer0();
181 ptimer_stop(s
->ptimer0
);
183 ptimer_transaction_commit(s
->ptimer0
);
185 case R_TIMER1_CONTROL
:
186 ptimer_transaction_begin(s
->ptimer1
);
187 s
->regs
[addr
] = value
;
188 if (s
->regs
[R_TIMER1_CONTROL
] & CTRL_ENABLE
) {
189 trace_milkymist_sysctl_start_timer1();
190 ptimer_set_count(s
->ptimer1
,
191 s
->regs
[R_TIMER1_COMPARE
] - s
->regs
[R_TIMER1_COUNTER
]);
192 ptimer_run(s
->ptimer1
, 0);
194 trace_milkymist_sysctl_stop_timer1();
195 ptimer_stop(s
->ptimer1
);
197 ptimer_transaction_commit(s
->ptimer1
);
200 sysctl_icap_write(s
, value
);
202 case R_DBG_WRITE_LOCK
:
206 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET
);
210 case R_CLK_FREQUENCY
:
212 error_report("milkymist_sysctl: write to read-only register 0x"
213 TARGET_FMT_plx
, addr
<< 2);
217 error_report("milkymist_sysctl: write access to unknown register 0x"
218 TARGET_FMT_plx
, addr
<< 2);
223 static const MemoryRegionOps sysctl_mmio_ops
= {
225 .write
= sysctl_write
,
227 .min_access_size
= 4,
228 .max_access_size
= 4,
230 .endianness
= DEVICE_NATIVE_ENDIAN
,
233 static void timer0_hit(void *opaque
)
235 MilkymistSysctlState
*s
= opaque
;
237 if (!(s
->regs
[R_TIMER0_CONTROL
] & CTRL_AUTORESTART
)) {
238 s
->regs
[R_TIMER0_CONTROL
] &= ~CTRL_ENABLE
;
239 trace_milkymist_sysctl_stop_timer0();
240 ptimer_stop(s
->ptimer0
);
243 trace_milkymist_sysctl_pulse_irq_timer0();
244 qemu_irq_pulse(s
->timer0_irq
);
247 static void timer1_hit(void *opaque
)
249 MilkymistSysctlState
*s
= opaque
;
251 if (!(s
->regs
[R_TIMER1_CONTROL
] & CTRL_AUTORESTART
)) {
252 s
->regs
[R_TIMER1_CONTROL
] &= ~CTRL_ENABLE
;
253 trace_milkymist_sysctl_stop_timer1();
254 ptimer_stop(s
->ptimer1
);
257 trace_milkymist_sysctl_pulse_irq_timer1();
258 qemu_irq_pulse(s
->timer1_irq
);
261 static void milkymist_sysctl_reset(DeviceState
*d
)
263 MilkymistSysctlState
*s
= MILKYMIST_SYSCTL(d
);
266 for (i
= 0; i
< R_MAX
; i
++) {
270 ptimer_transaction_begin(s
->ptimer0
);
271 ptimer_stop(s
->ptimer0
);
272 ptimer_transaction_commit(s
->ptimer0
);
273 ptimer_transaction_begin(s
->ptimer1
);
274 ptimer_stop(s
->ptimer1
);
275 ptimer_transaction_commit(s
->ptimer1
);
278 s
->regs
[R_ICAP
] = ICAP_READY
;
279 s
->regs
[R_SYSTEM_ID
] = s
->systemid
;
280 s
->regs
[R_CLK_FREQUENCY
] = s
->freq_hz
;
281 s
->regs
[R_CAPABILITIES
] = s
->capabilities
;
282 s
->regs
[R_GPIO_IN
] = s
->strappings
;
285 static void milkymist_sysctl_init(Object
*obj
)
287 MilkymistSysctlState
*s
= MILKYMIST_SYSCTL(obj
);
288 SysBusDevice
*dev
= SYS_BUS_DEVICE(obj
);
290 sysbus_init_irq(dev
, &s
->gpio_irq
);
291 sysbus_init_irq(dev
, &s
->timer0_irq
);
292 sysbus_init_irq(dev
, &s
->timer1_irq
);
294 memory_region_init_io(&s
->regs_region
, obj
, &sysctl_mmio_ops
, s
,
295 "milkymist-sysctl", R_MAX
* 4);
296 sysbus_init_mmio(dev
, &s
->regs_region
);
299 static void milkymist_sysctl_realize(DeviceState
*dev
, Error
**errp
)
301 MilkymistSysctlState
*s
= MILKYMIST_SYSCTL(dev
);
303 s
->ptimer0
= ptimer_init(timer0_hit
, s
, PTIMER_POLICY_DEFAULT
);
304 s
->ptimer1
= ptimer_init(timer1_hit
, s
, PTIMER_POLICY_DEFAULT
);
306 ptimer_transaction_begin(s
->ptimer0
);
307 ptimer_set_freq(s
->ptimer0
, s
->freq_hz
);
308 ptimer_transaction_commit(s
->ptimer0
);
309 ptimer_transaction_begin(s
->ptimer1
);
310 ptimer_set_freq(s
->ptimer1
, s
->freq_hz
);
311 ptimer_transaction_commit(s
->ptimer1
);
314 static const VMStateDescription vmstate_milkymist_sysctl
= {
315 .name
= "milkymist-sysctl",
317 .minimum_version_id
= 1,
318 .fields
= (VMStateField
[]) {
319 VMSTATE_UINT32_ARRAY(regs
, MilkymistSysctlState
, R_MAX
),
320 VMSTATE_PTIMER(ptimer0
, MilkymistSysctlState
),
321 VMSTATE_PTIMER(ptimer1
, MilkymistSysctlState
),
322 VMSTATE_END_OF_LIST()
326 static Property milkymist_sysctl_properties
[] = {
327 DEFINE_PROP_UINT32("frequency", MilkymistSysctlState
,
329 DEFINE_PROP_UINT32("capabilities", MilkymistSysctlState
,
330 capabilities
, 0x00000000),
331 DEFINE_PROP_UINT32("systemid", MilkymistSysctlState
,
332 systemid
, 0x10014d31),
333 DEFINE_PROP_UINT32("gpio_strappings", MilkymistSysctlState
,
334 strappings
, 0x00000001),
335 DEFINE_PROP_END_OF_LIST(),
338 static void milkymist_sysctl_class_init(ObjectClass
*klass
, void *data
)
340 DeviceClass
*dc
= DEVICE_CLASS(klass
);
342 dc
->realize
= milkymist_sysctl_realize
;
343 dc
->reset
= milkymist_sysctl_reset
;
344 dc
->vmsd
= &vmstate_milkymist_sysctl
;
345 device_class_set_props(dc
, milkymist_sysctl_properties
);
348 static const TypeInfo milkymist_sysctl_info
= {
349 .name
= TYPE_MILKYMIST_SYSCTL
,
350 .parent
= TYPE_SYS_BUS_DEVICE
,
351 .instance_size
= sizeof(MilkymistSysctlState
),
352 .instance_init
= milkymist_sysctl_init
,
353 .class_init
= milkymist_sysctl_class_init
,
356 static void milkymist_sysctl_register_types(void)
358 type_register_static(&milkymist_sysctl_info
);
361 type_init(milkymist_sysctl_register_types
)