Merge tag 'seabios-20211203-pull-request' of git://git.kraxel.org/qemu into staging
[qemu.git] / hw / timer / renesas_cmt.c
1 /*
2 * Renesas 16bit Compare-match timer
3 *
4 * Datasheet: RX62N Group, RX621 Group User's Manual: Hardware
5 * (Rev.1.40 R01UH0033EJ0140)
6 *
7 * Copyright (c) 2019 Yoshinori Sato
8 *
9 * SPDX-License-Identifier: GPL-2.0-or-later
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms and conditions of the GNU General Public License,
13 * version 2 or later, as published by the Free Software Foundation.
14 *
15 * This program is distributed in the hope it will be useful, but WITHOUT
16 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
18 * more details.
19 *
20 * You should have received a copy of the GNU General Public License along with
21 * this program. If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "qemu/osdep.h"
25 #include "qemu/log.h"
26 #include "hw/irq.h"
27 #include "hw/registerfields.h"
28 #include "hw/qdev-properties.h"
29 #include "hw/timer/renesas_cmt.h"
30 #include "migration/vmstate.h"
31
32 /*
33 * +0 CMSTR - common control
34 * +2 CMCR - ch0
35 * +4 CMCNT - ch0
36 * +6 CMCOR - ch0
37 * +8 CMCR - ch1
38 * +10 CMCNT - ch1
39 * +12 CMCOR - ch1
40 * If we think that the address of CH 0 has an offset of +2,
41 * we can treat it with the same address as CH 1, so define it like that.
42 */
43 REG16(CMSTR, 0)
44 FIELD(CMSTR, STR0, 0, 1)
45 FIELD(CMSTR, STR1, 1, 1)
46 FIELD(CMSTR, STR, 0, 2)
47 /* This addeess is channel offset */
48 REG16(CMCR, 0)
49 FIELD(CMCR, CKS, 0, 2)
50 FIELD(CMCR, CMIE, 6, 1)
51 REG16(CMCNT, 2)
52 REG16(CMCOR, 4)
53
54 static void update_events(RCMTState *cmt, int ch)
55 {
56 int64_t next_time;
57
58 if ((cmt->cmstr & (1 << ch)) == 0) {
59 /* count disable, so not happened next event. */
60 return ;
61 }
62 next_time = cmt->cmcor[ch] - cmt->cmcnt[ch];
63 next_time *= NANOSECONDS_PER_SECOND;
64 next_time /= cmt->input_freq;
65 /*
66 * CKS -> div rate
67 * 0 -> 8 (1 << 3)
68 * 1 -> 32 (1 << 5)
69 * 2 -> 128 (1 << 7)
70 * 3 -> 512 (1 << 9)
71 */
72 next_time *= 1 << (3 + FIELD_EX16(cmt->cmcr[ch], CMCR, CKS) * 2);
73 next_time += qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
74 timer_mod(&cmt->timer[ch], next_time);
75 }
76
77 static int64_t read_cmcnt(RCMTState *cmt, int ch)
78 {
79 int64_t delta, now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
80
81 if (cmt->cmstr & (1 << ch)) {
82 delta = (now - cmt->tick[ch]);
83 delta /= NANOSECONDS_PER_SECOND;
84 delta /= cmt->input_freq;
85 delta /= 1 << (3 + FIELD_EX16(cmt->cmcr[ch], CMCR, CKS) * 2);
86 cmt->tick[ch] = now;
87 return cmt->cmcnt[ch] + delta;
88 } else {
89 return cmt->cmcnt[ch];
90 }
91 }
92
93 static uint64_t cmt_read(void *opaque, hwaddr offset, unsigned size)
94 {
95 RCMTState *cmt = opaque;
96 int ch = offset / 0x08;
97 uint64_t ret;
98
99 if (offset == A_CMSTR) {
100 ret = 0;
101 ret = FIELD_DP16(ret, CMSTR, STR,
102 FIELD_EX16(cmt->cmstr, CMSTR, STR));
103 return ret;
104 } else {
105 offset &= 0x07;
106 if (ch == 0) {
107 offset -= 0x02;
108 }
109 switch (offset) {
110 case A_CMCR:
111 ret = 0;
112 ret = FIELD_DP16(ret, CMCR, CKS,
113 FIELD_EX16(cmt->cmstr, CMCR, CKS));
114 ret = FIELD_DP16(ret, CMCR, CMIE,
115 FIELD_EX16(cmt->cmstr, CMCR, CMIE));
116 return ret;
117 case A_CMCNT:
118 return read_cmcnt(cmt, ch);
119 case A_CMCOR:
120 return cmt->cmcor[ch];
121 }
122 }
123 qemu_log_mask(LOG_UNIMP, "renesas_cmt: Register 0x%" HWADDR_PRIX " "
124 "not implemented\n",
125 offset);
126 return UINT64_MAX;
127 }
128
129 static void start_stop(RCMTState *cmt, int ch, int st)
130 {
131 if (st) {
132 update_events(cmt, ch);
133 } else {
134 timer_del(&cmt->timer[ch]);
135 }
136 }
137
138 static void cmt_write(void *opaque, hwaddr offset, uint64_t val, unsigned size)
139 {
140 RCMTState *cmt = opaque;
141 int ch = offset / 0x08;
142
143 if (offset == A_CMSTR) {
144 cmt->cmstr = FIELD_EX16(val, CMSTR, STR);
145 start_stop(cmt, 0, FIELD_EX16(cmt->cmstr, CMSTR, STR0));
146 start_stop(cmt, 1, FIELD_EX16(cmt->cmstr, CMSTR, STR1));
147 } else {
148 offset &= 0x07;
149 if (ch == 0) {
150 offset -= 0x02;
151 }
152 switch (offset) {
153 case A_CMCR:
154 cmt->cmcr[ch] = FIELD_DP16(cmt->cmcr[ch], CMCR, CKS,
155 FIELD_EX16(val, CMCR, CKS));
156 cmt->cmcr[ch] = FIELD_DP16(cmt->cmcr[ch], CMCR, CMIE,
157 FIELD_EX16(val, CMCR, CMIE));
158 break;
159 case 2:
160 cmt->cmcnt[ch] = val;
161 break;
162 case 4:
163 cmt->cmcor[ch] = val;
164 break;
165 default:
166 qemu_log_mask(LOG_UNIMP, "renesas_cmt: Register 0x%" HWADDR_PRIX " "
167 "not implemented\n",
168 offset);
169 return;
170 }
171 if (FIELD_EX16(cmt->cmstr, CMSTR, STR) & (1 << ch)) {
172 update_events(cmt, ch);
173 }
174 }
175 }
176
177 static const MemoryRegionOps cmt_ops = {
178 .write = cmt_write,
179 .read = cmt_read,
180 .endianness = DEVICE_NATIVE_ENDIAN,
181 .impl = {
182 .min_access_size = 2,
183 .max_access_size = 2,
184 },
185 .valid = {
186 .min_access_size = 2,
187 .max_access_size = 2,
188 },
189 };
190
191 static void timer_events(RCMTState *cmt, int ch)
192 {
193 cmt->cmcnt[ch] = 0;
194 cmt->tick[ch] = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
195 update_events(cmt, ch);
196 if (FIELD_EX16(cmt->cmcr[ch], CMCR, CMIE)) {
197 qemu_irq_pulse(cmt->cmi[ch]);
198 }
199 }
200
201 static void timer_event0(void *opaque)
202 {
203 RCMTState *cmt = opaque;
204
205 timer_events(cmt, 0);
206 }
207
208 static void timer_event1(void *opaque)
209 {
210 RCMTState *cmt = opaque;
211
212 timer_events(cmt, 1);
213 }
214
215 static void rcmt_reset(DeviceState *dev)
216 {
217 RCMTState *cmt = RCMT(dev);
218 cmt->cmstr = 0;
219 cmt->cmcr[0] = cmt->cmcr[1] = 0;
220 cmt->cmcnt[0] = cmt->cmcnt[1] = 0;
221 cmt->cmcor[0] = cmt->cmcor[1] = 0xffff;
222 }
223
224 static void rcmt_init(Object *obj)
225 {
226 SysBusDevice *d = SYS_BUS_DEVICE(obj);
227 RCMTState *cmt = RCMT(obj);
228 int i;
229
230 memory_region_init_io(&cmt->memory, OBJECT(cmt), &cmt_ops,
231 cmt, "renesas-cmt", 0x10);
232 sysbus_init_mmio(d, &cmt->memory);
233
234 for (i = 0; i < ARRAY_SIZE(cmt->cmi); i++) {
235 sysbus_init_irq(d, &cmt->cmi[i]);
236 }
237 timer_init_ns(&cmt->timer[0], QEMU_CLOCK_VIRTUAL, timer_event0, cmt);
238 timer_init_ns(&cmt->timer[1], QEMU_CLOCK_VIRTUAL, timer_event1, cmt);
239 }
240
241 static const VMStateDescription vmstate_rcmt = {
242 .name = "rx-cmt",
243 .version_id = 1,
244 .minimum_version_id = 1,
245 .fields = (VMStateField[]) {
246 VMSTATE_UINT16(cmstr, RCMTState),
247 VMSTATE_UINT16_ARRAY(cmcr, RCMTState, CMT_CH),
248 VMSTATE_UINT16_ARRAY(cmcnt, RCMTState, CMT_CH),
249 VMSTATE_UINT16_ARRAY(cmcor, RCMTState, CMT_CH),
250 VMSTATE_INT64_ARRAY(tick, RCMTState, CMT_CH),
251 VMSTATE_TIMER_ARRAY(timer, RCMTState, CMT_CH),
252 VMSTATE_END_OF_LIST()
253 }
254 };
255
256 static Property rcmt_properties[] = {
257 DEFINE_PROP_UINT64("input-freq", RCMTState, input_freq, 0),
258 DEFINE_PROP_END_OF_LIST(),
259 };
260
261 static void rcmt_class_init(ObjectClass *klass, void *data)
262 {
263 DeviceClass *dc = DEVICE_CLASS(klass);
264
265 dc->vmsd = &vmstate_rcmt;
266 dc->reset = rcmt_reset;
267 device_class_set_props(dc, rcmt_properties);
268 }
269
270 static const TypeInfo rcmt_info = {
271 .name = TYPE_RENESAS_CMT,
272 .parent = TYPE_SYS_BUS_DEVICE,
273 .instance_size = sizeof(RCMTState),
274 .instance_init = rcmt_init,
275 .class_init = rcmt_class_init,
276 };
277
278 static void rcmt_register_types(void)
279 {
280 type_register_static(&rcmt_info);
281 }
282
283 type_init(rcmt_register_types)