Model the K230 RTC: date/time keeping with leap-year carry, write protection, a masked comparator alarm, a TICK_EN periodic tick interrupt, and a live sub-second COUNT derived from virtual time. The alarm is re-evaluated on TIME/ALARM/INT_CTRL writes and the year comparison ignores the DATE leap flag. Register layout from the K230 TRM v0.3.1. Covered by tests/qtest/k230-rtc-test.
Signed-off-by: Leo Cheng <[email protected]> --- hw/rtc/Kconfig | 3 + hw/rtc/k230_rtc.c | 306 ++++++++++++++++++++++++++++++++++++ hw/rtc/meson.build | 1 + hw/rtc/trace-events | 5 + include/hw/rtc/k230_rtc.h | 61 +++++++ tests/qtest/k230-rtc-test.c | 188 ++++++++++++++++++++++ 6 files changed, 564 insertions(+) create mode 100644 hw/rtc/k230_rtc.c create mode 100644 include/hw/rtc/k230_rtc.h create mode 100644 tests/qtest/k230-rtc-test.c diff --git a/hw/rtc/Kconfig b/hw/rtc/Kconfig index 315b0e4..d764807 100644 --- a/hw/rtc/Kconfig +++ b/hw/rtc/Kconfig @@ -31,3 +31,6 @@ config RS5C372_RTC bool depends on I2C default y if I2C_DEVICES + +config K230_RTC + bool diff --git a/hw/rtc/k230_rtc.c b/hw/rtc/k230_rtc.c new file mode 100644 index 0000000..c1de83d --- /dev/null +++ b/hw/rtc/k230_rtc.c @@ -0,0 +1,306 @@ +/* + * K230 RTC compatible with Kendryte K230 SDK + * + * Copyright (c) 2026 Leo Cheng <[email protected]> + * + * SPDX-License-Identifier: GPL-2.0-or-later + * + * K230 Technical Reference Manual V0.3.1 (2024-11-18): + * https://github.com/revyos/external-docs/blob/master/K230/en-us/K230_Technical_Reference_Manual_V0.3.1_20241118.pdf + * + * For more information, see <https://www.kendryte.com/en/proDetail/230> + */ +#include "qemu/osdep.h" +#include "qemu/bitops.h" +#include "qemu/module.h" +#include "qemu/timer.h" +#include "hw/core/irq.h" +#include "migration/vmstate.h" +#include "hw/rtc/k230_rtc.h" +#include "trace.h" + +static bool k230_rtc_is_leap(uint32_t year) +{ + return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0; +} + +static void k230_rtc_advance(K230RtcState *s) +{ + uint32_t sec = extract32(s->time, 0, 6); + uint32_t min = extract32(s->time, 8, 6); + uint32_t hour = extract32(s->time, 16, 5); + uint32_t week = extract32(s->time, 24, 3); + uint32_t day = extract32(s->date, 0, 5); + uint32_t month = extract32(s->date, 8, 4); + uint32_t year_l = extract32(s->date, 16, 7); + uint32_t year_h = extract32(s->date, 24, 7); + static const uint8_t dim[12] = {31, 28, 31, 30, 31, 30, + 31, 31, 30, 31, 30, 31}; + + if (++sec >= 60) { + sec = 0; + if (++min >= 60) { + min = 0; + if (++hour >= 24) { + uint32_t year = year_h * 100 + year_l; + uint32_t maxd = month >= 1 && month <= 12 ? dim[month - 1] : 31; + + hour = 0; + week = (week + 1) % 7; + if (month == 2 && k230_rtc_is_leap(year)) { + maxd = 29; + } + if (++day > maxd) { + day = 1; + if (++month > 12) { + month = 1; + if (++year_l >= 100) { + year_l = 0; + year_h++; + } + } + } + } + } + } + + s->time = deposit32(deposit32(deposit32(deposit32(0, 0, 6, sec), + 8, 6, min), 16, 5, hour), 24, 3, week); + s->date = deposit32(deposit32(deposit32(deposit32(deposit32(0, 0, 5, day), + 8, 4, month), 16, 7, year_l), 24, 7, year_h), + 23, 1, k230_rtc_is_leap(year_h * 100 + year_l)); +} + +static void k230_rtc_update_irq(K230RtcState *s) +{ + qemu_set_irq(s->irq, s->alarm_pending || s->tick_pending); +} + +static void k230_rtc_check_alarm(K230RtcState *s) +{ + uint32_t cmp = extract32(s->int_ctrl, K230_RTC_CMP_SHIFT, 7); + bool match = true; + + if (!(s->int_ctrl & K230_RTC_ALARM_EN) || cmp == 0) { + return; + } + + if (cmp & BIT(0)) { /* second */ + match &= extract32(s->time, 0, 6) == extract32(s->alarm_time, 0, 6); + } + if (cmp & BIT(1)) { /* minute */ + match &= extract32(s->time, 8, 6) == extract32(s->alarm_time, 8, 6); + } + if (cmp & BIT(2)) { /* hour */ + match &= extract32(s->time, 16, 5) == extract32(s->alarm_time, 16, 5); + } + if (cmp & BIT(3)) { /* weekday */ + match &= extract32(s->time, 24, 3) == extract32(s->alarm_time, 24, 3); + } + if (cmp & BIT(4)) { /* day */ + match &= extract32(s->date, 0, 5) == extract32(s->alarm_date, 0, 5); + } + if (cmp & BIT(5)) { /* month */ + match &= extract32(s->date, 8, 4) == extract32(s->alarm_date, 8, 4); + } + if (cmp & BIT(6)) { /* year: skip leap flag at bit 23 */ + match &= extract32(s->date, 16, 7) == extract32(s->alarm_date, 16, 7) && + extract32(s->date, 24, 7) == extract32(s->alarm_date, 24, 7); + } + + if (match) { + s->alarm_pending = true; + k230_rtc_update_irq(s); + trace_k230_rtc_alarm(); + } +} + +static void k230_rtc_tick(void *opaque) +{ + K230RtcState *s = K230_RTC(opaque); + + s->last_tick_ns = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); + k230_rtc_advance(s); + if (s->int_ctrl & K230_RTC_TICK_EN) { + s->tick_pending = true; + } + k230_rtc_check_alarm(s); + k230_rtc_update_irq(s); + timer_mod(s->timer, s->last_tick_ns + NANOSECONDS_PER_SECOND); +} + +static uint64_t k230_rtc_read(void *opaque, hwaddr addr, unsigned int size) +{ + K230RtcState *s = K230_RTC(opaque); + uint32_t value = 0; + + switch (addr) { + case K230_RTC_DATE: + value = s->date; + break; + case K230_RTC_TIME: + value = s->time; + break; + case K230_RTC_ALARM_DATE: + value = s->alarm_date; + break; + case K230_RTC_ALARM_TIME: + value = s->alarm_time; + break; + case K230_RTC_COUNT: { + uint32_t sum = extract32(s->count, 16, 16); + int64_t elapsed = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) - + s->last_tick_ns; + uint64_t curr = 0; + + if (elapsed > 0) { + curr = (uint64_t)elapsed * (sum + 1) / NANOSECONDS_PER_SECOND; + } + if (curr > sum) { + curr = sum; + } + value = (sum << 16) | (uint32_t)curr; + break; + } + case K230_RTC_INT_CTRL: + value = s->int_ctrl; + break; + default: + break; + } + + trace_k230_rtc_read(addr, value); + return value; +} + +static void k230_rtc_write(void *opaque, hwaddr addr, + uint64_t value, unsigned int size) +{ + K230RtcState *s = K230_RTC(opaque); + bool w_en = s->int_ctrl & K230_RTC_TIMER_W_EN; + + trace_k230_rtc_write(addr, value); + + switch (addr) { + case K230_RTC_DATE: + if (w_en) { + s->date = value; + k230_rtc_check_alarm(s); + } + break; + case K230_RTC_TIME: + if (w_en) { + s->time = value; + k230_rtc_check_alarm(s); + } + break; + case K230_RTC_ALARM_DATE: + s->alarm_date = value; + k230_rtc_check_alarm(s); + break; + case K230_RTC_ALARM_TIME: + s->alarm_time = value; + k230_rtc_check_alarm(s); + break; + case K230_RTC_COUNT: + if (w_en) { + s->count = value; + s->last_tick_ns = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); + } + break; + case K230_RTC_INT_CTRL: + if (value & K230_RTC_ALARM_CLR) { + s->alarm_pending = false; + s->tick_pending = false; + value &= ~K230_RTC_ALARM_CLR; + } + s->int_ctrl = value; + k230_rtc_check_alarm(s); + k230_rtc_update_irq(s); + break; + default: + break; + } +} + +static const MemoryRegionOps k230_rtc_ops = { + .read = k230_rtc_read, + .write = k230_rtc_write, + .endianness = DEVICE_LITTLE_ENDIAN, + .impl = { + .min_access_size = 4, + .max_access_size = 4, + .unaligned = false, + }, +}; + +static void k230_rtc_reset(DeviceState *dev) +{ + K230RtcState *s = K230_RTC(dev); + + s->date = 0; + s->time = 0; + s->alarm_date = 0; + s->alarm_time = 0; + s->count = 32767u << 16; + s->int_ctrl = 0; + s->alarm_pending = false; + s->tick_pending = false; + s->last_tick_ns = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); + qemu_set_irq(s->irq, 0); + + timer_mod(s->timer, s->last_tick_ns + NANOSECONDS_PER_SECOND); +} + +static const VMStateDescription vmstate_k230_rtc = { + .name = "k230.rtc", + .fields = (const VMStateField[]) { + VMSTATE_TIMER_PTR(timer, K230RtcState), + VMSTATE_UINT32(date, K230RtcState), + VMSTATE_UINT32(time, K230RtcState), + VMSTATE_UINT32(alarm_date, K230RtcState), + VMSTATE_UINT32(alarm_time, K230RtcState), + VMSTATE_UINT32(count, K230RtcState), + VMSTATE_UINT32(int_ctrl, K230RtcState), + VMSTATE_INT64(last_tick_ns, K230RtcState), + VMSTATE_BOOL(alarm_pending, K230RtcState), + VMSTATE_BOOL(tick_pending, K230RtcState), + VMSTATE_END_OF_LIST() + } +}; + +static void k230_rtc_realize(DeviceState *dev, Error **errp) +{ + K230RtcState *s = K230_RTC(dev); + SysBusDevice *sbd = SYS_BUS_DEVICE(dev); + + memory_region_init_io(&s->mmio, OBJECT(dev), &k230_rtc_ops, s, + TYPE_K230_RTC, K230_RTC_MMIO_SIZE); + sysbus_init_mmio(sbd, &s->mmio); + sysbus_init_irq(sbd, &s->irq); + + s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, k230_rtc_tick, s); +} + +static void k230_rtc_class_init(ObjectClass *klass, const void *data) +{ + DeviceClass *dc = DEVICE_CLASS(klass); + + dc->realize = k230_rtc_realize; + device_class_set_legacy_reset(dc, k230_rtc_reset); + dc->vmsd = &vmstate_k230_rtc; + dc->desc = "K230 RTC"; +} + +static const TypeInfo k230_rtc_info = { + .name = TYPE_K230_RTC, + .parent = TYPE_SYS_BUS_DEVICE, + .instance_size = sizeof(K230RtcState), + .class_init = k230_rtc_class_init, +}; + +static void k230_rtc_register_type(void) +{ + type_register_static(&k230_rtc_info); +} +type_init(k230_rtc_register_type) diff --git a/hw/rtc/meson.build b/hw/rtc/meson.build index 6c87864..3f3529c 100644 --- a/hw/rtc/meson.build +++ b/hw/rtc/meson.build @@ -14,3 +14,4 @@ system_ss.add(when: 'CONFIG_LS7A_RTC', if_true: files('ls7a_rtc.c')) system_ss.add(when: 'CONFIG_ALLWINNER_H3', if_true: files('allwinner-rtc.c')) system_ss.add(when: 'CONFIG_MC146818RTC', if_true: files('mc146818rtc.c')) system_ss.add(when: 'CONFIG_RS5C372_RTC', if_true: files('rs5c372.c')) +system_ss.add(when: 'CONFIG_K230_RTC', if_true: files('k230_rtc.c')) diff --git a/hw/rtc/trace-events b/hw/rtc/trace-events index d2f3621..beee3b1 100644 --- a/hw/rtc/trace-events +++ b/hw/rtc/trace-events @@ -43,3 +43,8 @@ goldfish_rtc_write(uint64_t addr, uint64_t value) "addr 0x%02" PRIx64 " value 0x # rs5c372.c rs5c372_recv(uint32_t addr, uint8_t value) "[0x%" PRIx32 "] -> 0x%02" PRIx8 rs5c372_send(uint32_t addr, uint8_t value) "[0x%" PRIx32 "] <- 0x%02" PRIx8 + +# k230_rtc.c +k230_rtc_read(uint64_t addr, uint32_t data) "K230 RTC read: [0x%" PRIx64 "] -> 0x%" PRIx32 +k230_rtc_write(uint64_t addr, uint64_t data) "K230 RTC write: [0x%" PRIx64 "] <- 0x%" PRIx64 +k230_rtc_alarm(void) "K230 RTC alarm" diff --git a/include/hw/rtc/k230_rtc.h b/include/hw/rtc/k230_rtc.h new file mode 100644 index 0000000..678ee37 --- /dev/null +++ b/include/hw/rtc/k230_rtc.h @@ -0,0 +1,61 @@ +/* + * K230 RTC compatible with Kendryte K230 SDK + * + * Copyright (c) 2026 Leo Cheng <[email protected]> + * + * SPDX-License-Identifier: GPL-2.0-or-later + * + * K230 Technical Reference Manual V0.3.1 (2024-11-18): + * https://github.com/revyos/external-docs/blob/master/K230/en-us/K230_Technical_Reference_Manual_V0.3.1_20241118.pdf + * + * For more information, see <https://www.kendryte.com/en/proDetail/230> + */ +#ifndef HW_RTC_K230_RTC_H +#define HW_RTC_K230_RTC_H + +#include "hw/core/sysbus.h" +#include "qemu/timer.h" +#include "qom/object.h" + +#define TYPE_K230_RTC "riscv.k230.rtc" +OBJECT_DECLARE_SIMPLE_TYPE(K230RtcState, K230_RTC) + +#define K230_RTC_MMIO_SIZE 0x400 + +enum { + K230_RTC_DATE = 0x00, + K230_RTC_TIME = 0x04, + K230_RTC_ALARM_DATE = 0x08, + K230_RTC_ALARM_TIME = 0x0c, + K230_RTC_COUNT = 0x10, + K230_RTC_INT_CTRL = 0x14, +}; + +/* INT_CTRL bits */ +#define K230_RTC_TIMER_W_EN (1u << 0) +#define K230_RTC_TIMER_R_EN (1u << 1) +#define K230_RTC_TICK_EN (1u << 8) +#define K230_RTC_ALARM_EN (1u << 16) +#define K230_RTC_ALARM_CLR (1u << 17) +#define K230_RTC_CMP_SHIFT 24 +#define K230_RTC_CMP_SECOND (1u << 24) + +struct K230RtcState { + SysBusDevice parent_obj; + + MemoryRegion mmio; + qemu_irq irq; + QEMUTimer *timer; + + uint32_t date; + uint32_t time; + uint32_t alarm_date; + uint32_t alarm_time; + uint32_t count; + uint32_t int_ctrl; + int64_t last_tick_ns; + bool alarm_pending; + bool tick_pending; +}; + +#endif diff --git a/tests/qtest/k230-rtc-test.c b/tests/qtest/k230-rtc-test.c new file mode 100644 index 0000000..081f21d --- /dev/null +++ b/tests/qtest/k230-rtc-test.c @@ -0,0 +1,188 @@ +/* + * QTest testcase for K230 RTC + * + * Copyright (c) 2026 Leo Cheng <[email protected]> + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ +#include "qemu/osdep.h" +#include "qemu/timer.h" +#include "libqtest.h" +#include "hw/rtc/k230_rtc.h" + +#define RTC_BASE 0x91000C00 + +#define PLIC_BASE 0xF00000000ULL +#define PLIC_PENDING (PLIC_BASE + 0x1000) +#define RTC_IRQ 175 + +static bool plic_pending(QTestState *qts, int irq) +{ + uint32_t word = qtest_readl(qts, PLIC_PENDING + (irq / 32) * 4); + return (word >> (irq % 32)) & 1; +} + +static void test_reset_values(void) +{ + QTestState *qts = qtest_init("-machine k230"); + + g_assert_cmphex(qtest_readl(qts, RTC_BASE + K230_RTC_INT_CTRL), ==, 0); + + qtest_quit(qts); +} + +/* Write-protect: date/time writes need timer_w_en */ +static void test_write_protect(void) +{ + QTestState *qts = qtest_init("-machine k230"); + + /* Protected: with w_en clear, writes are ignored */ + qtest_writel(qts, RTC_BASE + K230_RTC_INT_CTRL, 0); + qtest_writel(qts, RTC_BASE + K230_RTC_TIME, 0x0A); + g_assert_cmphex(qtest_readl(qts, RTC_BASE + K230_RTC_TIME), ==, 0); + + /* Unlocked: enable then write date + time, read back */ + qtest_writel(qts, RTC_BASE + K230_RTC_INT_CTRL, K230_RTC_TIMER_W_EN); + qtest_writel(qts, RTC_BASE + K230_RTC_DATE, (6 << 8) | 15); /* Jun 15 */ + qtest_writel(qts, RTC_BASE + K230_RTC_TIME, + (12 << 16) | (30 << 8) | 45); /* 12:30:45 */ + g_assert_cmphex(qtest_readl(qts, RTC_BASE + K230_RTC_DATE), ==, + (6 << 8) | 15); + g_assert_cmphex(qtest_readl(qts, RTC_BASE + K230_RTC_TIME), ==, + (12 << 16) | (30 << 8) | 45); + + qtest_quit(qts); +} + +/* One virtual second advances TIME.second */ +static void test_tick(void) +{ + QTestState *qts = qtest_init("-machine k230"); + + qtest_writel(qts, RTC_BASE + K230_RTC_INT_CTRL, K230_RTC_TIMER_W_EN); + qtest_writel(qts, RTC_BASE + K230_RTC_TIME, 10); /* second = 10 */ + + qtest_clock_step(qts, NANOSECONDS_PER_SECOND); + g_assert_cmpuint(qtest_readl(qts, RTC_BASE + K230_RTC_TIME) & 0x3F, ==, 11); + + qtest_quit(qts); +} + +/* Masked second alarm raises the RTC interrupt; cleared by alarm_clr */ +static void test_alarm(void) +{ + QTestState *qts = qtest_init("-machine k230"); + + qtest_writel(qts, RTC_BASE + K230_RTC_INT_CTRL, K230_RTC_TIMER_W_EN); + qtest_writel(qts, RTC_BASE + K230_RTC_TIME, 10); + qtest_writel(qts, RTC_BASE + K230_RTC_ALARM_TIME, 11); + qtest_writel(qts, RTC_BASE + K230_RTC_INT_CTRL, + K230_RTC_ALARM_EN | K230_RTC_CMP_SECOND); + + qtest_clock_step(qts, NANOSECONDS_PER_SECOND); + g_assert_true(plic_pending(qts, RTC_IRQ)); + + /* + * alarm_clr is write-1 self-clearing and lowers the RTC IRQ line; the + * PLIC pending bit is sticky until claimed, so verify the ack bit here. + */ + qtest_writel(qts, RTC_BASE + K230_RTC_INT_CTRL, + K230_RTC_ALARM_EN | K230_RTC_CMP_SECOND | K230_RTC_ALARM_CLR); + g_assert_cmphex(qtest_readl(qts, RTC_BASE + K230_RTC_INT_CTRL), ==, + K230_RTC_ALARM_EN | K230_RTC_CMP_SECOND); + + qtest_quit(qts); +} + +/* COUNT sub-second field advances with virtual time within the second */ +static void test_count_live(void) +{ + QTestState *qts = qtest_init("-machine k230"); + uint32_t count; + + /* half a second in -> curr = (sum+1)/2, sum field unchanged */ + qtest_clock_step(qts, NANOSECONDS_PER_SECOND / 2); + count = qtest_readl(qts, RTC_BASE + K230_RTC_COUNT); + g_assert_cmpuint(count >> 16, ==, 32767); + g_assert_cmpuint(count & 0xFFFF, ==, 16384); + + qtest_quit(qts); +} + +/* TICK_EN turns the 1 Hz advance into a periodic interrupt; gated by TICK_EN */ +static void test_tick_irq(void) +{ + QTestState *qts = qtest_init("-machine k230"); + + /* No TICK_EN: a tick advances time but raises no interrupt */ + qtest_writel(qts, RTC_BASE + K230_RTC_INT_CTRL, K230_RTC_TIMER_W_EN); + qtest_clock_step(qts, NANOSECONDS_PER_SECOND); + g_assert_false(plic_pending(qts, RTC_IRQ)); + + /* TICK_EN set: the next tick raises the shared RTC interrupt */ + qtest_writel(qts, RTC_BASE + K230_RTC_INT_CTRL, + K230_RTC_TIMER_W_EN | K230_RTC_TICK_EN); + qtest_clock_step(qts, NANOSECONDS_PER_SECOND); + g_assert_true(plic_pending(qts, RTC_IRQ)); + + qtest_quit(qts); +} + +/* Enabling an alarm whose time already matches fires without waiting a tick */ +static void test_alarm_immediate(void) +{ + QTestState *qts = qtest_init("-machine k230"); + + qtest_writel(qts, RTC_BASE + K230_RTC_INT_CTRL, K230_RTC_TIMER_W_EN); + qtest_writel(qts, RTC_BASE + K230_RTC_TIME, 10); + qtest_writel(qts, RTC_BASE + K230_RTC_ALARM_TIME, 10); + + /* enable while already matching -> immediate, no clock step */ + qtest_writel(qts, RTC_BASE + K230_RTC_INT_CTRL, + K230_RTC_TIMER_W_EN | K230_RTC_ALARM_EN | K230_RTC_CMP_SECOND); + g_assert_true(plic_pending(qts, RTC_IRQ)); + + qtest_quit(qts); +} + +/* + * Year alarm must match in a leap year: advance() sets a leap flag at DATE + * bit 23, which must not contaminate the year comparison. + */ +static void test_alarm_year_leap(void) +{ + QTestState *qts = qtest_init("-machine k230"); + uint32_t date2024 = (20u << 24) | (24u << 16) | (6u << 8) | 15u; /* 2024 */ + + qtest_writel(qts, RTC_BASE + K230_RTC_INT_CTRL, K230_RTC_TIMER_W_EN); + qtest_writel(qts, RTC_BASE + K230_RTC_DATE, date2024); + /* one tick makes advance() set the leap flag (bit 23) in DATE */ + qtest_clock_step(qts, NANOSECONDS_PER_SECOND); + + qtest_writel(qts, RTC_BASE + K230_RTC_INT_CTRL, + K230_RTC_TIMER_W_EN | K230_RTC_ALARM_EN | + ((1u << 6) << K230_RTC_CMP_SHIFT)); /* year compare */ + g_assert_false(plic_pending(qts, RTC_IRQ)); /* alarm_date still 0 */ + + qtest_writel(qts, RTC_BASE + K230_RTC_ALARM_DATE, + (20u << 24) | (24u << 16)); + g_assert_true(plic_pending(qts, RTC_IRQ)); /* matches despite leap flag */ + + qtest_quit(qts); +} + +int main(int argc, char **argv) +{ + g_test_init(&argc, &argv, NULL); + + qtest_add_func("/k230-rtc/reset_values", test_reset_values); + qtest_add_func("/k230-rtc/write_protect", test_write_protect); + qtest_add_func("/k230-rtc/tick", test_tick); + qtest_add_func("/k230-rtc/alarm", test_alarm); + qtest_add_func("/k230-rtc/count_live", test_count_live); + qtest_add_func("/k230-rtc/tick_irq", test_tick_irq); + qtest_add_func("/k230-rtc/alarm_immediate", test_alarm_immediate); + qtest_add_func("/k230-rtc/alarm_year_leap", test_alarm_year_leap); + + return g_test_run(); +} -- 2.43.0
