/* * Samsung exynos4210 Real Time Clock * * Copyright (c) 2012 Samsung Electronics Co., Ltd. * Ogurtsov Oleg <o.ogurtsov@samsung.com> * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, see <http://www.gnu.org/licenses/>. * */ /* Description: * Register RTCCON: * CLKSEL Bit[1] not used * CLKOUTEN Bit[9] not used */ #include "hw/sysbus.h" #include "qemu/timer.h" #include "qemu-common.h" #include "hw/ptimer.h" #include "hw/hw.h" #include "sysemu/sysemu.h" #include "hw/arm/exynos4210.h" #define DEBUG_RTC 0 #if DEBUG_RTC #define DPRINTF(fmt, ...) \ do { fprintf(stdout, "RTC: [%24s:%5d] " fmt, __func__, __LINE__, \ ## __VA_ARGS__); } while (0) #else #define DPRINTF(fmt, ...) do {} while (0) #endif #define EXYNOS4210_RTC_REG_MEM_SIZE 0x0100 #define INTP 0x0030 #define RTCCON 0x0040 #define TICCNT 0x0044 #define RTCALM 0x0050 #define ALMSEC 0x0054 #define ALMMIN 0x0058 #define ALMHOUR 0x005C #define ALMDAY 0x0060 #define ALMMON 0x0064 #define ALMYEAR 0x0068 #define BCDSEC 0x0070 #define BCDMIN 0x0074 #define BCDHOUR 0x0078 #define BCDDAY 0x007C #define BCDDAYWEEK 0x0080 #define BCDMON 0x0084 #define BCDYEAR 0x0088 #define CURTICNT 0x0090 #define TICK_TIMER_ENABLE 0x0100 #define TICNT_THRESHOLD 2 #define RTC_ENABLE 0x0001 #define INTP_TICK_ENABLE 0x0001 #define INTP_ALM_ENABLE 0x0002 #define ALARM_INT_ENABLE 0x0040 #define RTC_BASE_FREQ 32768 #define TYPE_EXYNOS4210_RTC "exynos4210.rtc" #define EXYNOS4210_RTC(obj) \ OBJECT_CHECK(Exynos4210RTCState, (obj), TYPE_EXYNOS4210_RTC) typedef struct Exynos4210RTCState { SysBusDevice parent_obj; MemoryRegion iomem; /* registers */ uint32_t reg_intp; uint32_t reg_rtccon; uint32_t reg_ticcnt; uint32_t reg_rtcalm; uint32_t reg_almsec; uint32_t reg_almmin; uint32_t reg_almhour; uint32_t reg_almday; uint32_t reg_almmon; uint32_t reg_almyear; uint32_t reg_curticcnt; ptimer_state *ptimer; /* tick timer */ ptimer_state *ptimer_1Hz; /* clock timer */ uint32_t freq; qemu_irq tick_irq; /* Time Tick Generator irq */ qemu_irq alm_irq; /* alarm irq */ struct tm current_tm; /* current time */ } Exynos4210RTCState; #define TICCKSEL(value) ((value & (0x0F << 4)) >> 4) /*** VMState ***/ static const VMStateDescription vmstate_exynos4210_rtc_state = { .name = "exynos4210.rtc", .version_id = 1, .minimum_version_id = 1, .fields = (VMStateField[]) { VMSTATE_UINT32(reg_intp, Exynos4210RTCState), VMSTATE_UINT32(reg_rtccon, Exynos4210RTCState), VMSTATE_UINT32(reg_ticcnt, Exynos4210RTCState), VMSTATE_UINT32(reg_rtcalm, Exynos4210RTCState), VMSTATE_UINT32(reg_almsec, Exynos4210RTCState), VMSTATE_UINT32(reg_almmin, Exynos4210RTCState), VMSTATE_UINT32(reg_almhour, Exynos4210RTCState), VMSTATE_UINT32(reg_almday, Exynos4210RTCState), VMSTATE_UINT32(reg_almmon, Exynos4210RTCState), VMSTATE_UINT32(reg_almyear, Exynos4210RTCState), VMSTATE_UINT32(reg_curticcnt, Exynos4210RTCState), VMSTATE_PTIMER(ptimer, Exynos4210RTCState), VMSTATE_PTIMER(ptimer_1Hz, Exynos4210RTCState), VMSTATE_UINT32(freq, Exynos4210RTCState), VMSTATE_INT32(current_tm.tm_sec, Exynos4210RTCState), VMSTATE_INT32(current_tm.tm_min, Exynos4210RTCState), VMSTATE_INT32(current_tm.tm_hour, Exynos4210RTCState), VMSTATE_INT32(current_tm.tm_wday, Exynos4210RTCState), VMSTATE_INT32(current_tm.tm_mday, Exynos4210RTCState), VMSTATE_INT32(current_tm.tm_mon, Exynos4210RTCState), VMSTATE_INT32(current_tm.tm_year, Exynos4210RTCState), VMSTATE_END_OF_LIST() } }; #define BCD3DIGITS(x) \ ((uint32_t)to_bcd((uint8_t)(x % 100)) + \ ((uint32_t)to_bcd((uint8_t)((x % 1000) / 100)) << 8)) static void check_alarm_raise(Exynos4210RTCState *s) { unsigned int alarm_raise = 0; struct tm stm = s->current_tm; if ((s->reg_rtcalm & 0x01) && (to_bcd((uint8_t)stm.tm_sec) == (uint8_t)s->reg_almsec)) { alarm_raise = 1; } if ((s->reg_rtcalm & 0x02) && (to_bcd((uint8_t)stm.tm_min) == (uint8_t)s->reg_almmin)) { alarm_raise = 1; } if ((s->reg_rtcalm & 0x04) && (to_bcd((uint8_t)stm.tm_hour) == (uint8_t)s->reg_almhour)) { alarm_raise = 1; } if ((s->reg_rtcalm & 0x08) && (to_bcd((uint8_t)stm.tm_mday) == (uint8_t)s->reg_almday)) { alarm_raise = 1; } if ((s->reg_rtcalm & 0x10) && (to_bcd((uint8_t)stm.tm_mon) == (uint8_t)s->reg_almmon)) { alarm_raise = 1; } if ((s->reg_rtcalm & 0x20) && (BCD3DIGITS(stm.tm_year) == s->reg_almyear)) { alarm_raise = 1; } if (alarm_raise) { DPRINTF("ALARM IRQ\n"); /* set irq status */ s->reg_intp |= INTP_ALM_ENABLE; qemu_irq_raise(s->alm_irq); } } /* * RTC update frequency * Parameters: * reg_value - current RTCCON register or his new value */ static void exynos4210_rtc_update_freq(Exynos4210RTCState *s, uint32_t reg_value) { uint32_t freq; freq = s->freq; /* set frequncy for time generator */ s->freq = RTC_BASE_FREQ / (1 << TICCKSEL(reg_value)); if (freq != s->freq) { ptimer_set_freq(s->ptimer, s->freq); DPRINTF("freq=%dHz\n", s->freq); } } /* month is between 0 and 11. */ static int get_days_in_month(int month, int year) { static const int days_tab[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; int d; if ((unsigned)month >= 12) { return 31; } d = days_tab[month]; if (month == 1) { if ((year % 4) == 0 && ((year % 100) != 0 || (year % 400) == 0)) { d++; } } return d; } /* update 'tm' to the next second */ static void rtc_next_second(struct tm *tm) { int days_in_month; tm->tm_sec++; if ((unsigned)tm->tm_sec >= 60) { tm->tm_sec = 0; tm->tm_min++; if ((unsigned)tm->tm_min >= 60) { tm->tm_min = 0; tm->tm_hour++; if ((unsigned)tm->tm_hour >= 24) { tm->tm_hour = 0; /* next day */ tm->tm_wday++; if ((unsigned)tm->tm_wday >= 7) { tm->tm_wday = 0; } days_in_month = get_days_in_month(tm->tm_mon, tm->tm_year + 1900); tm->tm_mday++; if (tm->tm_mday < 1) { tm->tm_mday = 1; } else if (tm->tm_mday > days_in_month) { tm->tm_mday = 1; tm->tm_mon++; if (tm->tm_mon >= 12) { tm->tm_mon = 0; tm->tm_year++; } } } } } } /* * tick handler */ static void exynos4210_rtc_tick(void *opaque) { Exynos4210RTCState *s = (Exynos4210RTCState *)opaque; DPRINTF("TICK IRQ\n"); /* set irq status */ s->reg_intp |= INTP_TICK_ENABLE; /* raise IRQ */ qemu_irq_raise(s->tick_irq); /* restart timer */ ptimer_set_count(s->ptimer, s->reg_ticcnt); ptimer_run(s->ptimer, 1); } /* * 1Hz clock handler */ static void exynos4210_rtc_1Hz_tick(void *opaque) { Exynos4210RTCState *s = (Exynos4210RTCState *)opaque; rtc_next_second(&s->current_tm); /* DPRINTF("1Hz tick\n"); */ /* raise IRQ */ if (s->reg_rtcalm & ALARM_INT_ENABLE) { check_alarm_raise(s); } ptimer_set_count(s->ptimer_1Hz, RTC_BASE_FREQ); ptimer_run(s->ptimer_1Hz, 1); } /* * RTC Read */ static uint64_t exynos4210_rtc_read(void *opaque, hwaddr offset, unsigned size) { uint32_t value = 0; Exynos4210RTCState *s = (Exynos4210RTCState *)opaque; switch (offset) { case INTP: value = s->reg_intp; break; case RTCCON: value = s->reg_rtccon; break; case TICCNT: value = s->reg_ticcnt; break; case RTCALM: value = s->reg_rtcalm; break; case ALMSEC: value = s->reg_almsec; break; case ALMMIN: value = s->reg_almmin; break; case ALMHOUR: value = s->reg_almhour; break; case ALMDAY: value = s->reg_almday; break; case ALMMON: value = s->reg_almmon; break; case ALMYEAR: value = s->reg_almyear; break; case BCDSEC: value = (uint32_t)to_bcd((uint8_t)s->current_tm.tm_sec); break; case BCDMIN: value = (uint32_t)to_bcd((uint8_t)s->current_tm.tm_min); break; case BCDHOUR: value = (uint32_t)to_bcd((uint8_t)s->current_tm.tm_hour); break; case BCDDAYWEEK: value = (uint32_t)to_bcd((uint8_t)s->current_tm.tm_wday); break; case BCDDAY: value = (uint32_t)to_bcd((uint8_t)s->current_tm.tm_mday); break; case BCDMON: value = (uint32_t)to_bcd((uint8_t)s->current_tm.tm_mon + 1); break; case BCDYEAR: value = BCD3DIGITS(s->current_tm.tm_year); break; case CURTICNT: s->reg_curticcnt = ptimer_get_count(s->ptimer); value = s->reg_curticcnt; break; default: fprintf(stderr, "[exynos4210.rtc: bad read offset " TARGET_FMT_plx "]\n", offset); break; } return value; } /* * RTC Write */ static void exynos4210_rtc_write(void *opaque, hwaddr offset, uint64_t value, unsigned size) { Exynos4210RTCState *s = (Exynos4210RTCState *)opaque; switch (offset) { case INTP: if (value & INTP_ALM_ENABLE) { qemu_irq_lower(s->alm_irq); s->reg_intp &= (~INTP_ALM_ENABLE); } if (value & INTP_TICK_ENABLE) { qemu_irq_lower(s->tick_irq); s->reg_intp &= (~INTP_TICK_ENABLE); } break; case RTCCON: if (value & RTC_ENABLE) { exynos4210_rtc_update_freq(s, value); } if ((value & RTC_ENABLE) > (s->reg_rtccon & RTC_ENABLE)) { /* clock timer */ ptimer_set_count(s->ptimer_1Hz, RTC_BASE_FREQ); ptimer_run(s->ptimer_1Hz, 1); DPRINTF("run clock timer\n"); } if ((value & RTC_ENABLE) < (s->reg_rtccon & RTC_ENABLE)) { /* tick timer */ ptimer_stop(s->ptimer); /* clock timer */ ptimer_stop(s->ptimer_1Hz); DPRINTF("stop all timers\n"); } if (value & RTC_ENABLE) { if ((value & TICK_TIMER_ENABLE) > (s->reg_rtccon & TICK_TIMER_ENABLE) && (s->reg_ticcnt)) { ptimer_set_count(s->ptimer, s->reg_ticcnt); ptimer_run(s->ptimer, 1); DPRINTF("run tick timer\n"); } if ((value & TICK_TIMER_ENABLE) < (s->reg_rtccon & TICK_TIMER_ENABLE)) { ptimer_stop(s->ptimer); } } s->reg_rtccon = value; break; case TICCNT: if (value > TICNT_THRESHOLD) { s->reg_ticcnt = value; } else { fprintf(stderr, "[exynos4210.rtc: bad TICNT value %u ]\n", (uint32_t)value); } break; case RTCALM: s->reg_rtcalm = value; break; case ALMSEC: s->reg_almsec = (value & 0x7f); break; case ALMMIN: s->reg_almmin = (value & 0x7f); break; case ALMHOUR: s->reg_almhour = (value & 0x3f); break; case ALMDAY: s->reg_almday = (value & 0x3f); break; case ALMMON: s->reg_almmon = (value & 0x1f); break; case ALMYEAR: s->reg_almyear = (value & 0x0fff); break; case BCDSEC: if (s->reg_rtccon & RTC_ENABLE) { s->current_tm.tm_sec = (int)from_bcd((uint8_t)value); } break; case BCDMIN: if (s->reg_rtccon & RTC_ENABLE) { s->current_tm.tm_min = (int)from_bcd((uint8_t)value); } break; case BCDHOUR: if (s->reg_rtccon & RTC_ENABLE) { s->current_tm.tm_hour = (int)from_bcd((uint8_t)value); } break; case BCDDAYWEEK: if (s->reg_rtccon & RTC_ENABLE) { s->current_tm.tm_wday = (int)from_bcd((uint8_t)value); } break; case BCDDAY: if (s->reg_rtccon & RTC_ENABLE) { s->current_tm.tm_mday = (int)from_bcd((uint8_t)value); } break; case BCDMON: if (s->reg_rtccon & RTC_ENABLE) { s->current_tm.tm_mon = (int)from_bcd((uint8_t)value) - 1; } break; case BCDYEAR: if (s->reg_rtccon & RTC_ENABLE) { /* 3 digits */ s->current_tm.tm_year = (int)from_bcd((uint8_t)value) + (int)from_bcd((uint8_t)((value >> 8) & 0x0f)) * 100; } break; default: fprintf(stderr, "[exynos4210.rtc: bad write offset " TARGET_FMT_plx "]\n", offset); break; } } /* * Set default values to timer fields and registers */ static void exynos4210_rtc_reset(DeviceState *d) { Exynos4210RTCState *s = EXYNOS4210_RTC(d); qemu_get_timedate(&s->current_tm, 0); DPRINTF("Get time from host: %d-%d-%d %2d:%02d:%02d\n", s->current_tm.tm_year, s->current_tm.tm_mon, s->current_tm.tm_mday, s->current_tm.tm_hour, s->current_tm.tm_min, s->current_tm.tm_sec); s->reg_intp = 0; s->reg_rtccon = 0; s->reg_ticcnt = 0; s->reg_rtcalm = 0; s->reg_almsec = 0; s->reg_almmin = 0; s->reg_almhour = 0; s->reg_almday = 0; s->reg_almmon = 0; s->reg_almyear = 0; s->reg_curticcnt = 0; exynos4210_rtc_update_freq(s, s->reg_rtccon); ptimer_stop(s->ptimer); ptimer_stop(s->ptimer_1Hz); } static const MemoryRegionOps exynos4210_rtc_ops = { .read = exynos4210_rtc_read, .write = exynos4210_rtc_write, .endianness = DEVICE_NATIVE_ENDIAN, }; /* * RTC timer initialization */ static int exynos4210_rtc_init(SysBusDevice *dev) { Exynos4210RTCState *s = EXYNOS4210_RTC(dev); QEMUBH *bh; bh = qemu_bh_new(exynos4210_rtc_tick, s); s->ptimer = ptimer_init(bh); ptimer_set_freq(s->ptimer, RTC_BASE_FREQ); exynos4210_rtc_update_freq(s, 0); bh = qemu_bh_new(exynos4210_rtc_1Hz_tick, s); s->ptimer_1Hz = ptimer_init(bh); ptimer_set_freq(s->ptimer_1Hz, RTC_BASE_FREQ); sysbus_init_irq(dev, &s->alm_irq); sysbus_init_irq(dev, &s->tick_irq); memory_region_init_io(&s->iomem, OBJECT(s), &exynos4210_rtc_ops, s, "exynos4210-rtc", EXYNOS4210_RTC_REG_MEM_SIZE); sysbus_init_mmio(dev, &s->iomem); return 0; } static void exynos4210_rtc_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); k->init = exynos4210_rtc_init; dc->reset = exynos4210_rtc_reset; dc->vmsd = &vmstate_exynos4210_rtc_state; } static const TypeInfo exynos4210_rtc_info = { .name = TYPE_EXYNOS4210_RTC, .parent = TYPE_SYS_BUS_DEVICE, .instance_size = sizeof(Exynos4210RTCState), .class_init = exynos4210_rtc_class_init, }; static void exynos4210_rtc_register_types(void) { type_register_static(&exynos4210_rtc_info); } type_init(exynos4210_rtc_register_types)