1 // SPDX-License-Identifier: GPL-2.0 2 3 #include <linux/interrupt.h> 4 #include <linux/ioport.h> 5 #include <linux/clocksource.h> 6 #include <linux/clockchips.h> 7 #include <linux/module.h> 8 #include <linux/slab.h> 9 #include <linux/goldfish.h> 10 #include <clocksource/timer-goldfish.h> 11 12 struct goldfish_timer { 13 struct clocksource cs; 14 struct clock_event_device ced; 15 struct resource res; 16 void __iomem *base; 17 }; 18 ced_to_gf(struct clock_event_device * ced)19 static struct goldfish_timer *ced_to_gf(struct clock_event_device *ced) 20 { 21 return container_of(ced, struct goldfish_timer, ced); 22 } 23 cs_to_gf(struct clocksource * cs)24 static struct goldfish_timer *cs_to_gf(struct clocksource *cs) 25 { 26 return container_of(cs, struct goldfish_timer, cs); 27 } 28 goldfish_timer_read(struct clocksource * cs)29 static u64 goldfish_timer_read(struct clocksource *cs) 30 { 31 struct goldfish_timer *timerdrv = cs_to_gf(cs); 32 void __iomem *base = timerdrv->base; 33 u32 time_low, time_high; 34 u64 ticks; 35 36 /* 37 * time_low: get low bits of current time and update time_high 38 * time_high: get high bits of time at last time_low read 39 */ 40 time_low = gf_ioread32(base + TIMER_TIME_LOW); 41 time_high = gf_ioread32(base + TIMER_TIME_HIGH); 42 43 ticks = ((u64)time_high << 32) | time_low; 44 45 return ticks; 46 } 47 goldfish_timer_set_oneshot(struct clock_event_device * evt)48 static int goldfish_timer_set_oneshot(struct clock_event_device *evt) 49 { 50 struct goldfish_timer *timerdrv = ced_to_gf(evt); 51 void __iomem *base = timerdrv->base; 52 53 gf_iowrite32(0, base + TIMER_ALARM_HIGH); 54 gf_iowrite32(0, base + TIMER_ALARM_LOW); 55 gf_iowrite32(1, base + TIMER_IRQ_ENABLED); 56 57 return 0; 58 } 59 goldfish_timer_shutdown(struct clock_event_device * evt)60 static int goldfish_timer_shutdown(struct clock_event_device *evt) 61 { 62 struct goldfish_timer *timerdrv = ced_to_gf(evt); 63 void __iomem *base = timerdrv->base; 64 65 gf_iowrite32(0, base + TIMER_IRQ_ENABLED); 66 67 return 0; 68 } 69 goldfish_timer_next_event(unsigned long delta,struct clock_event_device * evt)70 static int goldfish_timer_next_event(unsigned long delta, 71 struct clock_event_device *evt) 72 { 73 struct goldfish_timer *timerdrv = ced_to_gf(evt); 74 void __iomem *base = timerdrv->base; 75 u64 now; 76 77 now = goldfish_timer_read(&timerdrv->cs); 78 79 now += delta; 80 81 gf_iowrite32(upper_32_bits(now), base + TIMER_ALARM_HIGH); 82 gf_iowrite32(lower_32_bits(now), base + TIMER_ALARM_LOW); 83 84 return 0; 85 } 86 goldfish_timer_irq(int irq,void * dev_id)87 static irqreturn_t goldfish_timer_irq(int irq, void *dev_id) 88 { 89 struct goldfish_timer *timerdrv = dev_id; 90 struct clock_event_device *evt = &timerdrv->ced; 91 void __iomem *base = timerdrv->base; 92 93 gf_iowrite32(1, base + TIMER_CLEAR_INTERRUPT); 94 95 evt->event_handler(evt); 96 97 return IRQ_HANDLED; 98 } 99 goldfish_timer_init(int irq,void __iomem * base)100 int __init goldfish_timer_init(int irq, void __iomem *base) 101 { 102 struct goldfish_timer *timerdrv; 103 int ret; 104 105 timerdrv = kzalloc(sizeof(*timerdrv), GFP_KERNEL); 106 if (!timerdrv) 107 return -ENOMEM; 108 109 timerdrv->base = base; 110 111 timerdrv->ced = (struct clock_event_device){ 112 .name = "goldfish_timer", 113 .features = CLOCK_EVT_FEAT_ONESHOT, 114 .set_state_shutdown = goldfish_timer_shutdown, 115 .set_state_oneshot = goldfish_timer_set_oneshot, 116 .set_next_event = goldfish_timer_next_event, 117 }; 118 119 timerdrv->res = (struct resource){ 120 .name = "goldfish_timer", 121 .start = (unsigned long)base, 122 .end = (unsigned long)base + 0xfff, 123 }; 124 125 ret = request_resource(&iomem_resource, &timerdrv->res); 126 if (ret) { 127 pr_err("Cannot allocate '%s' resource\n", timerdrv->res.name); 128 return ret; 129 } 130 131 timerdrv->cs = (struct clocksource){ 132 .name = "goldfish_timer", 133 .rating = 400, 134 .read = goldfish_timer_read, 135 .mask = CLOCKSOURCE_MASK(64), 136 .flags = 0, 137 .max_idle_ns = LONG_MAX, 138 }; 139 140 clocksource_register_hz(&timerdrv->cs, NSEC_PER_SEC); 141 142 ret = request_irq(irq, goldfish_timer_irq, IRQF_TIMER, 143 "goldfish_timer", timerdrv); 144 if (ret) { 145 pr_err("Couldn't register goldfish-timer interrupt\n"); 146 return ret; 147 } 148 149 clockevents_config_and_register(&timerdrv->ced, NSEC_PER_SEC, 150 1, 0xffffffff); 151 152 return 0; 153 } 154