The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 1 | /* Copyright (C) 2007-2008 The Android Open Source Project |
| 2 | ** |
| 3 | ** This software is licensed under the terms of the GNU General Public |
| 4 | ** License version 2, as published by the Free Software Foundation, and |
| 5 | ** may be copied, distributed, and modified under those terms. |
| 6 | ** |
| 7 | ** This program is distributed in the hope that it will be useful, |
| 8 | ** but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 9 | ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 10 | ** GNU General Public License for more details. |
| 11 | */ |
David 'Digit' Turner | a7fb77d | 2010-05-10 23:50:54 -0700 | [diff] [blame] | 12 | #include "qemu-common.h" |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 13 | #include "qemu-timer.h" |
| 14 | #include "cpu.h" |
| 15 | #include "arm_pic.h" |
| 16 | #include "goldfish_device.h" |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 17 | #include "hw/hw.h" |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 18 | |
| 19 | enum { |
| 20 | TIMER_TIME_LOW = 0x00, // get low bits of current time and update TIMER_TIME_HIGH |
| 21 | TIMER_TIME_HIGH = 0x04, // get high bits of time at last TIMER_TIME_LOW read |
| 22 | TIMER_ALARM_LOW = 0x08, // set low bits of alarm and activate it |
| 23 | TIMER_ALARM_HIGH = 0x0c, // set high bits of next alarm |
| 24 | TIMER_CLEAR_INTERRUPT = 0x10, |
| 25 | TIMER_CLEAR_ALARM = 0x14 |
| 26 | }; |
| 27 | |
| 28 | struct timer_state { |
| 29 | struct goldfish_device dev; |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 30 | uint32_t alarm_low_ns; |
| 31 | int32_t alarm_high_ns; |
| 32 | int64_t now_ns; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 33 | int armed; |
| 34 | QEMUTimer *timer; |
| 35 | }; |
| 36 | |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 37 | /* Converts nanoseconds into ticks */ |
| 38 | static int64_t ns2tks(int64_t ns) { |
| 39 | return muldiv64(ns, get_ticks_per_sec(), 1000000000); |
| 40 | } |
| 41 | |
| 42 | /* Converts ticks into nanoseconds */ |
| 43 | static int64_t tks2ns(int64_t tks) { |
| 44 | return muldiv64(tks, 1000000000, get_ticks_per_sec()); |
| 45 | } |
| 46 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 47 | #define GOLDFISH_TIMER_SAVE_VERSION 1 |
| 48 | |
| 49 | static void goldfish_timer_save(QEMUFile* f, void* opaque) |
| 50 | { |
| 51 | struct timer_state* s = opaque; |
| 52 | |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 53 | qemu_put_be64(f, s->now_ns); /* in case the kernel is in the middle of a timer read */ |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 54 | qemu_put_byte(f, s->armed); |
| 55 | if (s->armed) { |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 56 | int64_t now_tks = qemu_get_clock(vm_clock); |
| 57 | int64_t alarm_tks = ns2tks(s->alarm_low_ns | (int64_t)s->alarm_high_ns << 32); |
| 58 | qemu_put_be64(f, alarm_tks - now_tks); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 59 | } |
| 60 | } |
| 61 | |
| 62 | static int goldfish_timer_load(QEMUFile* f, void* opaque, int version_id) |
| 63 | { |
| 64 | struct timer_state* s = opaque; |
| 65 | |
| 66 | if (version_id != GOLDFISH_TIMER_SAVE_VERSION) |
| 67 | return -1; |
| 68 | |
Ot ten Thije | afb0f8e | 2010-09-22 15:47:33 +0100 | [diff] [blame] | 69 | s->now_ns = qemu_get_be64(f); |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 70 | s->armed = qemu_get_byte(f); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 71 | if (s->armed) { |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 72 | int64_t now_tks = qemu_get_clock(vm_clock); |
| 73 | int64_t diff_tks = qemu_get_be64(f); |
| 74 | int64_t alarm_tks = now_tks + diff_tks; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 75 | |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 76 | if (alarm_tks <= now_tks) { |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 77 | goldfish_device_set_irq(&s->dev, 0, 1); |
| 78 | s->armed = 0; |
| 79 | } else { |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 80 | qemu_mod_timer(s->timer, alarm_tks); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 81 | } |
| 82 | } |
| 83 | return 0; |
| 84 | } |
| 85 | |
| 86 | static uint32_t goldfish_timer_read(void *opaque, target_phys_addr_t offset) |
| 87 | { |
| 88 | struct timer_state *s = (struct timer_state *)opaque; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 89 | switch(offset) { |
| 90 | case TIMER_TIME_LOW: |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 91 | s->now_ns = tks2ns(qemu_get_clock(vm_clock)); |
| 92 | return s->now_ns; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 93 | case TIMER_TIME_HIGH: |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 94 | return s->now_ns >> 32; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 95 | default: |
| 96 | cpu_abort (cpu_single_env, "goldfish_timer_read: Bad offset %x\n", offset); |
| 97 | return 0; |
| 98 | } |
| 99 | } |
| 100 | |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 101 | static void goldfish_timer_write(void *opaque, target_phys_addr_t offset, uint32_t value_ns) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 102 | { |
| 103 | struct timer_state *s = (struct timer_state *)opaque; |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 104 | int64_t alarm_tks, now_tks; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 105 | switch(offset) { |
| 106 | case TIMER_ALARM_LOW: |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 107 | s->alarm_low_ns = value_ns; |
| 108 | alarm_tks = ns2tks(s->alarm_low_ns | (int64_t)s->alarm_high_ns << 32); |
| 109 | now_tks = qemu_get_clock(vm_clock); |
| 110 | if (alarm_tks <= now_tks) { |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 111 | goldfish_device_set_irq(&s->dev, 0, 1); |
| 112 | } else { |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 113 | qemu_mod_timer(s->timer, alarm_tks); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 114 | s->armed = 1; |
| 115 | } |
| 116 | break; |
| 117 | case TIMER_ALARM_HIGH: |
Ot ten Thije | a7f114b | 2010-09-06 15:03:52 +0100 | [diff] [blame] | 118 | s->alarm_high_ns = value_ns; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 119 | break; |
| 120 | case TIMER_CLEAR_ALARM: |
| 121 | qemu_del_timer(s->timer); |
| 122 | s->armed = 0; |
| 123 | /* fall through */ |
| 124 | case TIMER_CLEAR_INTERRUPT: |
| 125 | goldfish_device_set_irq(&s->dev, 0, 0); |
| 126 | break; |
| 127 | default: |
| 128 | cpu_abort (cpu_single_env, "goldfish_timer_write: Bad offset %x\n", offset); |
| 129 | } |
| 130 | } |
| 131 | |
| 132 | static void goldfish_timer_tick(void *opaque) |
| 133 | { |
| 134 | struct timer_state *s = (struct timer_state *)opaque; |
| 135 | |
| 136 | s->armed = 0; |
| 137 | goldfish_device_set_irq(&s->dev, 0, 1); |
| 138 | } |
| 139 | |
| 140 | struct rtc_state { |
| 141 | struct goldfish_device dev; |
| 142 | uint32_t alarm_low; |
| 143 | int32_t alarm_high; |
| 144 | int64_t now; |
| 145 | }; |
| 146 | |
| 147 | /* we save the RTC for the case where the kernel is in the middle of a rtc_read |
| 148 | * (i.e. it has read the low 32-bit of s->now, but not the high 32-bits yet */ |
| 149 | #define GOLDFISH_RTC_SAVE_VERSION 1 |
| 150 | |
| 151 | static void goldfish_rtc_save(QEMUFile* f, void* opaque) |
| 152 | { |
| 153 | struct rtc_state* s = opaque; |
| 154 | |
| 155 | qemu_put_be64(f, s->now); |
| 156 | } |
| 157 | |
| 158 | static int goldfish_rtc_load(QEMUFile* f, void* opaque, int version_id) |
| 159 | { |
| 160 | struct rtc_state* s = opaque; |
| 161 | |
| 162 | if (version_id != GOLDFISH_RTC_SAVE_VERSION) |
| 163 | return -1; |
| 164 | |
| 165 | /* this is an old value that is not correct. but that's ok anyway */ |
| 166 | s->now = qemu_get_be64(f); |
| 167 | return 0; |
| 168 | } |
| 169 | |
| 170 | static uint32_t goldfish_rtc_read(void *opaque, target_phys_addr_t offset) |
| 171 | { |
| 172 | struct rtc_state *s = (struct rtc_state *)opaque; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 173 | switch(offset) { |
| 174 | case 0x0: |
| 175 | s->now = (int64_t)time(NULL) * 1000000000; |
| 176 | return s->now; |
| 177 | case 0x4: |
| 178 | return s->now >> 32; |
| 179 | default: |
| 180 | cpu_abort (cpu_single_env, "goldfish_rtc_read: Bad offset %x\n", offset); |
| 181 | return 0; |
| 182 | } |
| 183 | } |
| 184 | |
| 185 | static void goldfish_rtc_write(void *opaque, target_phys_addr_t offset, uint32_t value) |
| 186 | { |
| 187 | struct rtc_state *s = (struct rtc_state *)opaque; |
| 188 | int64_t alarm; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 189 | switch(offset) { |
| 190 | case 0x8: |
| 191 | s->alarm_low = value; |
| 192 | alarm = s->alarm_low | (int64_t)s->alarm_high << 32; |
| 193 | //printf("next alarm at %lld, tps %lld\n", alarm, ticks_per_sec); |
| 194 | //qemu_mod_timer(s->timer, alarm); |
| 195 | break; |
| 196 | case 0xc: |
| 197 | s->alarm_high = value; |
| 198 | //printf("alarm_high %d\n", s->alarm_high); |
| 199 | break; |
| 200 | case 0x10: |
| 201 | goldfish_device_set_irq(&s->dev, 0, 0); |
| 202 | break; |
| 203 | default: |
| 204 | cpu_abort (cpu_single_env, "goldfish_rtc_write: Bad offset %x\n", offset); |
| 205 | } |
| 206 | } |
| 207 | |
| 208 | static struct timer_state timer_state = { |
| 209 | .dev = { |
| 210 | .name = "goldfish_timer", |
| 211 | .id = -1, |
| 212 | .size = 0x1000, |
| 213 | .irq_count = 1, |
| 214 | } |
| 215 | }; |
| 216 | |
| 217 | static struct timer_state rtc_state = { |
| 218 | .dev = { |
| 219 | .name = "goldfish_rtc", |
| 220 | .id = -1, |
| 221 | .size = 0x1000, |
| 222 | .irq_count = 1, |
| 223 | } |
| 224 | }; |
| 225 | |
| 226 | static CPUReadMemoryFunc *goldfish_timer_readfn[] = { |
| 227 | goldfish_timer_read, |
| 228 | goldfish_timer_read, |
| 229 | goldfish_timer_read |
| 230 | }; |
| 231 | |
| 232 | static CPUWriteMemoryFunc *goldfish_timer_writefn[] = { |
| 233 | goldfish_timer_write, |
| 234 | goldfish_timer_write, |
| 235 | goldfish_timer_write |
| 236 | }; |
| 237 | |
| 238 | static CPUReadMemoryFunc *goldfish_rtc_readfn[] = { |
| 239 | goldfish_rtc_read, |
| 240 | goldfish_rtc_read, |
| 241 | goldfish_rtc_read |
| 242 | }; |
| 243 | |
| 244 | static CPUWriteMemoryFunc *goldfish_rtc_writefn[] = { |
| 245 | goldfish_rtc_write, |
| 246 | goldfish_rtc_write, |
| 247 | goldfish_rtc_write |
| 248 | }; |
| 249 | |
| 250 | void goldfish_timer_and_rtc_init(uint32_t timerbase, int timerirq) |
| 251 | { |
| 252 | timer_state.dev.base = timerbase; |
| 253 | timer_state.dev.irq = timerirq; |
| 254 | timer_state.timer = qemu_new_timer(vm_clock, goldfish_timer_tick, &timer_state); |
| 255 | goldfish_device_add(&timer_state.dev, goldfish_timer_readfn, goldfish_timer_writefn, &timer_state); |
| 256 | register_savevm( "goldfish_timer", 0, GOLDFISH_TIMER_SAVE_VERSION, |
| 257 | goldfish_timer_save, goldfish_timer_load, &timer_state); |
| 258 | |
| 259 | goldfish_device_add(&rtc_state.dev, goldfish_rtc_readfn, goldfish_rtc_writefn, &rtc_state); |
| 260 | register_savevm( "goldfish_rtc", 0, GOLDFISH_RTC_SAVE_VERSION, |
| 261 | goldfish_rtc_save, goldfish_rtc_load, &rtc_state); |
| 262 | } |
| 263 | |