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