sifive_pwm.c (14851B)
1 /* 2 * SiFive PWM 3 * 4 * Copyright (c) 2020 Western Digital 5 * 6 * Author: Alistair Francis <alistair.francis@wdc.com> 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a copy 9 * of this software and associated documentation files (the "Software"), to deal 10 * in the Software without restriction, including without limitation the rights 11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 12 * copies of the Software, and to permit persons to whom the Software is 13 * furnished to do so, subject to the following conditions: 14 * 15 * The above copyright notice and this permission notice shall be included in 16 * all copies or substantial portions of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 24 * THE SOFTWARE. 25 */ 26 27 #include "qemu/osdep.h" 28 #include "trace.h" 29 #include "hw/irq.h" 30 #include "hw/timer/sifive_pwm.h" 31 #include "hw/qdev-properties.h" 32 #include "hw/registerfields.h" 33 #include "migration/vmstate.h" 34 #include "qemu/log.h" 35 #include "qemu/module.h" 36 37 #define HAS_PWM_EN_BITS(cfg) ((cfg & R_CONFIG_ENONESHOT_MASK) || \ 38 (cfg & R_CONFIG_ENALWAYS_MASK)) 39 40 #define PWMCMP_MASK 0xFFFF 41 #define PWMCOUNT_MASK 0x7FFFFFFF 42 43 REG32(CONFIG, 0x00) 44 FIELD(CONFIG, SCALE, 0, 4) 45 FIELD(CONFIG, STICKY, 8, 1) 46 FIELD(CONFIG, ZEROCMP, 9, 1) 47 FIELD(CONFIG, DEGLITCH, 10, 1) 48 FIELD(CONFIG, ENALWAYS, 12, 1) 49 FIELD(CONFIG, ENONESHOT, 13, 1) 50 FIELD(CONFIG, CMP0CENTER, 16, 1) 51 FIELD(CONFIG, CMP1CENTER, 17, 1) 52 FIELD(CONFIG, CMP2CENTER, 18, 1) 53 FIELD(CONFIG, CMP3CENTER, 19, 1) 54 FIELD(CONFIG, CMP0GANG, 24, 1) 55 FIELD(CONFIG, CMP1GANG, 25, 1) 56 FIELD(CONFIG, CMP2GANG, 26, 1) 57 FIELD(CONFIG, CMP3GANG, 27, 1) 58 FIELD(CONFIG, CMP0IP, 28, 1) 59 FIELD(CONFIG, CMP1IP, 29, 1) 60 FIELD(CONFIG, CMP2IP, 30, 1) 61 FIELD(CONFIG, CMP3IP, 31, 1) 62 REG32(COUNT, 0x08) 63 REG32(PWMS, 0x10) 64 REG32(PWMCMP0, 0x20) 65 REG32(PWMCMP1, 0x24) 66 REG32(PWMCMP2, 0x28) 67 REG32(PWMCMP3, 0x2C) 68 69 static inline uint64_t sifive_pwm_ns_to_ticks(SiFivePwmState *s, 70 uint64_t time) 71 { 72 return muldiv64(time, s->freq_hz, NANOSECONDS_PER_SECOND); 73 } 74 75 static inline uint64_t sifive_pwm_ticks_to_ns(SiFivePwmState *s, 76 uint64_t ticks) 77 { 78 return muldiv64(ticks, NANOSECONDS_PER_SECOND, s->freq_hz); 79 } 80 81 static inline uint64_t sifive_pwm_compute_scale(SiFivePwmState *s) 82 { 83 return s->pwmcfg & R_CONFIG_SCALE_MASK; 84 } 85 86 static void sifive_pwm_set_alarms(SiFivePwmState *s) 87 { 88 uint64_t now_ns = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); 89 90 if (HAS_PWM_EN_BITS(s->pwmcfg)) { 91 /* 92 * Subtract ticks from number of ticks when the timer was zero 93 * and mask to the register width. 94 */ 95 uint64_t pwmcount = (sifive_pwm_ns_to_ticks(s, now_ns) - 96 s->tick_offset) & PWMCOUNT_MASK; 97 uint64_t scale = sifive_pwm_compute_scale(s); 98 /* PWMs only contains PWMCMP_MASK bits starting at scale */ 99 uint64_t pwms = (pwmcount & (PWMCMP_MASK << scale)) >> scale; 100 101 for (int i = 0; i < SIFIVE_PWM_CHANS; i++) { 102 uint64_t pwmcmp = s->pwmcmp[i] & PWMCMP_MASK; 103 uint64_t pwmcmp_ticks = pwmcmp << scale; 104 105 /* 106 * Per circuit diagram and spec, both cases raises corresponding 107 * IP bit one clock cycle after time expires. 108 */ 109 if (pwmcmp > pwms) { 110 uint64_t offset = pwmcmp_ticks - pwmcount + 1; 111 uint64_t when_to_fire = now_ns + 112 sifive_pwm_ticks_to_ns(s, offset); 113 114 trace_sifive_pwm_set_alarm(when_to_fire, now_ns); 115 timer_mod(&s->timer[i], when_to_fire); 116 } else { 117 /* Schedule interrupt for next cycle */ 118 trace_sifive_pwm_set_alarm(now_ns + 1, now_ns); 119 timer_mod(&s->timer[i], now_ns + 1); 120 } 121 122 } 123 } else { 124 /* 125 * If timer incrementing disabled, just do pwms > pwmcmp check since 126 * a write may have happened to PWMs. 127 */ 128 uint64_t pwmcount = (s->tick_offset) & PWMCOUNT_MASK; 129 uint64_t scale = sifive_pwm_compute_scale(s); 130 uint64_t pwms = (pwmcount & (PWMCMP_MASK << scale)) >> scale; 131 132 for (int i = 0; i < SIFIVE_PWM_CHANS; i++) { 133 uint64_t pwmcmp = s->pwmcmp[i] & PWMCMP_MASK; 134 135 if (pwms >= pwmcmp) { 136 trace_sifive_pwm_set_alarm(now_ns + 1, now_ns); 137 timer_mod(&s->timer[i], now_ns + 1); 138 } else { 139 /* Effectively disable timer by scheduling far in future. */ 140 trace_sifive_pwm_set_alarm(0xFFFFFFFFFFFFFF, now_ns); 141 timer_mod(&s->timer[i], 0xFFFFFFFFFFFFFF); 142 } 143 } 144 } 145 } 146 147 static void sifive_pwm_interrupt(SiFivePwmState *s, int num) 148 { 149 uint64_t now = sifive_pwm_ns_to_ticks(s, 150 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL)); 151 bool was_incrementing = HAS_PWM_EN_BITS(s->pwmcfg); 152 153 trace_sifive_pwm_interrupt(num); 154 155 s->pwmcfg |= R_CONFIG_CMP0IP_MASK << num; 156 qemu_irq_raise(s->irqs[num]); 157 158 /* 159 * If the zerocmp is set and pwmcmp0 raised the interrupt 160 * reset the zero ticks. 161 */ 162 if ((s->pwmcfg & R_CONFIG_ZEROCMP_MASK) && (num == 0)) { 163 /* If reset signal conditions, disable ENONESHOT. */ 164 s->pwmcfg &= ~R_CONFIG_ENONESHOT_MASK; 165 166 if (was_incrementing) { 167 /* If incrementing, time in ticks is when pwmcount is zero */ 168 s->tick_offset = now; 169 } else { 170 /* If not incrementing, pwmcount = 0 */ 171 s->tick_offset = 0; 172 } 173 } 174 175 /* 176 * If carryout bit set, which we discern via looking for overflow, 177 * also reset ENONESHOT. 178 */ 179 if (was_incrementing && 180 ((now & PWMCOUNT_MASK) < (s->tick_offset & PWMCOUNT_MASK))) { 181 s->pwmcfg &= ~R_CONFIG_ENONESHOT_MASK; 182 } 183 184 /* Schedule or disable interrupts */ 185 sifive_pwm_set_alarms(s); 186 187 /* If was enabled, and now not enabled, switch tick rep */ 188 if (was_incrementing && !HAS_PWM_EN_BITS(s->pwmcfg)) { 189 s->tick_offset = (now - s->tick_offset) & PWMCOUNT_MASK; 190 } 191 } 192 193 static void sifive_pwm_interrupt_0(void *opaque) 194 { 195 SiFivePwmState *s = opaque; 196 197 sifive_pwm_interrupt(s, 0); 198 } 199 200 static void sifive_pwm_interrupt_1(void *opaque) 201 { 202 SiFivePwmState *s = opaque; 203 204 sifive_pwm_interrupt(s, 1); 205 } 206 207 static void sifive_pwm_interrupt_2(void *opaque) 208 { 209 SiFivePwmState *s = opaque; 210 211 sifive_pwm_interrupt(s, 2); 212 } 213 214 static void sifive_pwm_interrupt_3(void *opaque) 215 { 216 SiFivePwmState *s = opaque; 217 218 sifive_pwm_interrupt(s, 3); 219 } 220 221 static uint64_t sifive_pwm_read(void *opaque, hwaddr addr, 222 unsigned int size) 223 { 224 SiFivePwmState *s = opaque; 225 uint64_t cur_time, scale; 226 uint64_t now = sifive_pwm_ns_to_ticks(s, 227 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL)); 228 229 trace_sifive_pwm_read(addr); 230 231 switch (addr) { 232 case A_CONFIG: 233 return s->pwmcfg; 234 case A_COUNT: 235 cur_time = s->tick_offset; 236 237 if (HAS_PWM_EN_BITS(s->pwmcfg)) { 238 cur_time = now - cur_time; 239 } 240 241 /* 242 * Return the value in the counter with bit 31 always 0 243 * This is allowed to wrap around so we don't need to check that. 244 */ 245 return cur_time & PWMCOUNT_MASK; 246 case A_PWMS: 247 cur_time = s->tick_offset; 248 scale = sifive_pwm_compute_scale(s); 249 250 if (HAS_PWM_EN_BITS(s->pwmcfg)) { 251 cur_time = now - cur_time; 252 } 253 254 return ((cur_time & PWMCOUNT_MASK) >> scale) & PWMCMP_MASK; 255 case A_PWMCMP0: 256 return s->pwmcmp[0] & PWMCMP_MASK; 257 case A_PWMCMP1: 258 return s->pwmcmp[1] & PWMCMP_MASK; 259 case A_PWMCMP2: 260 return s->pwmcmp[2] & PWMCMP_MASK; 261 case A_PWMCMP3: 262 return s->pwmcmp[3] & PWMCMP_MASK; 263 default: 264 qemu_log_mask(LOG_GUEST_ERROR, 265 "%s: Bad offset 0x%"HWADDR_PRIx"\n", __func__, addr); 266 return 0; 267 } 268 269 return 0; 270 } 271 272 static void sifive_pwm_write(void *opaque, hwaddr addr, 273 uint64_t val64, unsigned int size) 274 { 275 SiFivePwmState *s = opaque; 276 uint32_t value = val64; 277 uint64_t new_offset, scale; 278 uint64_t now = sifive_pwm_ns_to_ticks(s, 279 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL)); 280 281 trace_sifive_pwm_write(value, addr); 282 283 switch (addr) { 284 case A_CONFIG: 285 if (value & (R_CONFIG_CMP0CENTER_MASK | R_CONFIG_CMP1CENTER_MASK | 286 R_CONFIG_CMP2CENTER_MASK | R_CONFIG_CMP3CENTER_MASK)) { 287 qemu_log_mask(LOG_UNIMP, "%s: CMPxCENTER is not supported\n", 288 __func__); 289 } 290 291 if (value & (R_CONFIG_CMP0GANG_MASK | R_CONFIG_CMP1GANG_MASK | 292 R_CONFIG_CMP2GANG_MASK | R_CONFIG_CMP3GANG_MASK)) { 293 qemu_log_mask(LOG_UNIMP, "%s: CMPxGANG is not supported\n", 294 __func__); 295 } 296 297 if (value & (R_CONFIG_CMP0IP_MASK | R_CONFIG_CMP1IP_MASK | 298 R_CONFIG_CMP2IP_MASK | R_CONFIG_CMP3IP_MASK)) { 299 qemu_log_mask(LOG_UNIMP, "%s: CMPxIP is not supported\n", 300 __func__); 301 } 302 303 if (!(value & R_CONFIG_CMP0IP_MASK)) { 304 qemu_irq_lower(s->irqs[0]); 305 } 306 307 if (!(value & R_CONFIG_CMP1IP_MASK)) { 308 qemu_irq_lower(s->irqs[1]); 309 } 310 311 if (!(value & R_CONFIG_CMP2IP_MASK)) { 312 qemu_irq_lower(s->irqs[2]); 313 } 314 315 if (!(value & R_CONFIG_CMP3IP_MASK)) { 316 qemu_irq_lower(s->irqs[3]); 317 } 318 319 /* 320 * If this write enables the timer increment 321 * set the time when pwmcount was zero to be cur_time - pwmcount. 322 * If this write disables the timer increment 323 * convert back from pwmcount to the time in ticks 324 * when pwmcount was zero. 325 */ 326 if ((!HAS_PWM_EN_BITS(s->pwmcfg) && HAS_PWM_EN_BITS(value)) || 327 (HAS_PWM_EN_BITS(s->pwmcfg) && !HAS_PWM_EN_BITS(value))) { 328 s->tick_offset = (now - s->tick_offset) & PWMCOUNT_MASK; 329 } 330 331 s->pwmcfg = value; 332 break; 333 case A_COUNT: 334 /* The guest changed the counter, updated the offset value. */ 335 new_offset = value; 336 337 if (HAS_PWM_EN_BITS(s->pwmcfg)) { 338 new_offset = now - new_offset; 339 } 340 341 s->tick_offset = new_offset; 342 break; 343 case A_PWMS: 344 scale = sifive_pwm_compute_scale(s); 345 new_offset = (((value & PWMCMP_MASK) << scale) & PWMCOUNT_MASK); 346 347 if (HAS_PWM_EN_BITS(s->pwmcfg)) { 348 new_offset = now - new_offset; 349 } 350 351 s->tick_offset = new_offset; 352 break; 353 case A_PWMCMP0: 354 s->pwmcmp[0] = value & PWMCMP_MASK; 355 break; 356 case A_PWMCMP1: 357 s->pwmcmp[1] = value & PWMCMP_MASK; 358 break; 359 case A_PWMCMP2: 360 s->pwmcmp[2] = value & PWMCMP_MASK; 361 break; 362 case A_PWMCMP3: 363 s->pwmcmp[3] = value & PWMCMP_MASK; 364 break; 365 default: 366 qemu_log_mask(LOG_GUEST_ERROR, 367 "%s: Bad offset 0x%"HWADDR_PRIx"\n", __func__, addr); 368 } 369 370 /* Update the alarms to reflect possible updated values */ 371 sifive_pwm_set_alarms(s); 372 } 373 374 static void sifive_pwm_reset(DeviceState *dev) 375 { 376 SiFivePwmState *s = SIFIVE_PWM(dev); 377 uint64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); 378 379 s->pwmcfg = 0x00000000; 380 s->pwmcmp[0] = 0x00000000; 381 s->pwmcmp[1] = 0x00000000; 382 s->pwmcmp[2] = 0x00000000; 383 s->pwmcmp[3] = 0x00000000; 384 385 s->tick_offset = sifive_pwm_ns_to_ticks(s, now); 386 } 387 388 static const MemoryRegionOps sifive_pwm_ops = { 389 .read = sifive_pwm_read, 390 .write = sifive_pwm_write, 391 .endianness = DEVICE_NATIVE_ENDIAN, 392 }; 393 394 static const VMStateDescription vmstate_sifive_pwm = { 395 .name = TYPE_SIFIVE_PWM, 396 .version_id = 1, 397 .minimum_version_id = 1, 398 .fields = (VMStateField[]) { 399 VMSTATE_TIMER_ARRAY(timer, SiFivePwmState, 4), 400 VMSTATE_UINT64(tick_offset, SiFivePwmState), 401 VMSTATE_UINT32(pwmcfg, SiFivePwmState), 402 VMSTATE_UINT32_ARRAY(pwmcmp, SiFivePwmState, 4), 403 VMSTATE_END_OF_LIST() 404 } 405 }; 406 407 static Property sifive_pwm_properties[] = { 408 /* 0.5Ghz per spec after FSBL */ 409 DEFINE_PROP_UINT64("clock-frequency", struct SiFivePwmState, 410 freq_hz, 500000000ULL), 411 DEFINE_PROP_END_OF_LIST(), 412 }; 413 414 static void sifive_pwm_init(Object *obj) 415 { 416 SiFivePwmState *s = SIFIVE_PWM(obj); 417 int i; 418 419 for (i = 0; i < SIFIVE_PWM_IRQS; i++) { 420 sysbus_init_irq(SYS_BUS_DEVICE(obj), &s->irqs[i]); 421 } 422 423 memory_region_init_io(&s->mmio, obj, &sifive_pwm_ops, s, 424 TYPE_SIFIVE_PWM, 0x100); 425 sysbus_init_mmio(SYS_BUS_DEVICE(obj), &s->mmio); 426 } 427 428 static void sifive_pwm_realize(DeviceState *dev, Error **errp) 429 { 430 SiFivePwmState *s = SIFIVE_PWM(dev); 431 432 timer_init_ns(&s->timer[0], QEMU_CLOCK_VIRTUAL, 433 sifive_pwm_interrupt_0, s); 434 435 timer_init_ns(&s->timer[1], QEMU_CLOCK_VIRTUAL, 436 sifive_pwm_interrupt_1, s); 437 438 timer_init_ns(&s->timer[2], QEMU_CLOCK_VIRTUAL, 439 sifive_pwm_interrupt_2, s); 440 441 timer_init_ns(&s->timer[3], QEMU_CLOCK_VIRTUAL, 442 sifive_pwm_interrupt_3, s); 443 } 444 445 static void sifive_pwm_class_init(ObjectClass *klass, void *data) 446 { 447 DeviceClass *dc = DEVICE_CLASS(klass); 448 449 dc->reset = sifive_pwm_reset; 450 device_class_set_props(dc, sifive_pwm_properties); 451 dc->vmsd = &vmstate_sifive_pwm; 452 dc->realize = sifive_pwm_realize; 453 } 454 455 static const TypeInfo sifive_pwm_info = { 456 .name = TYPE_SIFIVE_PWM, 457 .parent = TYPE_SYS_BUS_DEVICE, 458 .instance_size = sizeof(SiFivePwmState), 459 .instance_init = sifive_pwm_init, 460 .class_init = sifive_pwm_class_init, 461 }; 462 463 static void sifive_pwm_register_types(void) 464 { 465 type_register_static(&sifive_pwm_info); 466 } 467 468 type_init(sifive_pwm_register_types)