1 // SPDX-License-Identifier: GPL-2.0
2 /* drivers/rtc/rtc-goldfish.c
3 *
4 * Copyright (C) 2007 Google, Inc.
5 * Copyright (C) 2017 Imagination Technologies Ltd.
6 */
7
8 #include <linux/io.h>
9 #include <linux/module.h>
10 #include <linux/of.h>
11 #include <linux/platform_device.h>
12 #include <linux/rtc.h>
13 #include <linux/goldfish.h>
14 #include <clocksource/timer-goldfish.h>
15
16 struct goldfish_rtc {
17 void __iomem *base;
18 int irq;
19 struct rtc_device *rtc;
20 };
21
goldfish_rtc_read_alarm(struct device * dev,struct rtc_wkalrm * alrm)22 static int goldfish_rtc_read_alarm(struct device *dev,
23 struct rtc_wkalrm *alrm)
24 {
25 u64 rtc_alarm;
26 u64 rtc_alarm_low;
27 u64 rtc_alarm_high;
28 void __iomem *base;
29 struct goldfish_rtc *rtcdrv;
30
31 rtcdrv = dev_get_drvdata(dev);
32 base = rtcdrv->base;
33
34 rtc_alarm_low = gf_ioread32(base + TIMER_ALARM_LOW);
35 rtc_alarm_high = gf_ioread32(base + TIMER_ALARM_HIGH);
36 rtc_alarm = (rtc_alarm_high << 32) | rtc_alarm_low;
37
38 do_div(rtc_alarm, NSEC_PER_SEC);
39 memset(alrm, 0, sizeof(struct rtc_wkalrm));
40
41 rtc_time64_to_tm(rtc_alarm, &alrm->time);
42
43 if (gf_ioread32(base + TIMER_ALARM_STATUS))
44 alrm->enabled = 1;
45 else
46 alrm->enabled = 0;
47
48 return 0;
49 }
50
goldfish_rtc_set_alarm(struct device * dev,struct rtc_wkalrm * alrm)51 static int goldfish_rtc_set_alarm(struct device *dev,
52 struct rtc_wkalrm *alrm)
53 {
54 struct goldfish_rtc *rtcdrv;
55 u64 rtc_alarm64;
56 u64 rtc_status_reg;
57 void __iomem *base;
58
59 rtcdrv = dev_get_drvdata(dev);
60 base = rtcdrv->base;
61
62 if (alrm->enabled) {
63 rtc_alarm64 = rtc_tm_to_time64(&alrm->time) * NSEC_PER_SEC;
64 gf_iowrite32((rtc_alarm64 >> 32), base + TIMER_ALARM_HIGH);
65 gf_iowrite32(rtc_alarm64, base + TIMER_ALARM_LOW);
66 gf_iowrite32(1, base + TIMER_IRQ_ENABLED);
67 } else {
68 /*
69 * if this function was called with enabled=0
70 * then it could mean that the application is
71 * trying to cancel an ongoing alarm
72 */
73 rtc_status_reg = gf_ioread32(base + TIMER_ALARM_STATUS);
74 if (rtc_status_reg)
75 gf_iowrite32(1, base + TIMER_CLEAR_ALARM);
76 }
77
78 return 0;
79 }
80
goldfish_rtc_alarm_irq_enable(struct device * dev,unsigned int enabled)81 static int goldfish_rtc_alarm_irq_enable(struct device *dev,
82 unsigned int enabled)
83 {
84 void __iomem *base;
85 struct goldfish_rtc *rtcdrv;
86
87 rtcdrv = dev_get_drvdata(dev);
88 base = rtcdrv->base;
89
90 if (enabled)
91 gf_iowrite32(1, base + TIMER_IRQ_ENABLED);
92 else
93 gf_iowrite32(0, base + TIMER_IRQ_ENABLED);
94
95 return 0;
96 }
97
goldfish_rtc_interrupt(int irq,void * dev_id)98 static irqreturn_t goldfish_rtc_interrupt(int irq, void *dev_id)
99 {
100 struct goldfish_rtc *rtcdrv = dev_id;
101 void __iomem *base = rtcdrv->base;
102
103 gf_iowrite32(1, base + TIMER_CLEAR_INTERRUPT);
104
105 rtc_update_irq(rtcdrv->rtc, 1, RTC_IRQF | RTC_AF);
106
107 return IRQ_HANDLED;
108 }
109
goldfish_rtc_read_time(struct device * dev,struct rtc_time * tm)110 static int goldfish_rtc_read_time(struct device *dev, struct rtc_time *tm)
111 {
112 struct goldfish_rtc *rtcdrv;
113 void __iomem *base;
114 u64 time_high;
115 u64 time_low;
116 u64 time;
117
118 rtcdrv = dev_get_drvdata(dev);
119 base = rtcdrv->base;
120
121 time_low = gf_ioread32(base + TIMER_TIME_LOW);
122 time_high = gf_ioread32(base + TIMER_TIME_HIGH);
123 time = (time_high << 32) | time_low;
124
125 do_div(time, NSEC_PER_SEC);
126
127 rtc_time64_to_tm(time, tm);
128
129 return 0;
130 }
131
goldfish_rtc_set_time(struct device * dev,struct rtc_time * tm)132 static int goldfish_rtc_set_time(struct device *dev, struct rtc_time *tm)
133 {
134 struct goldfish_rtc *rtcdrv;
135 void __iomem *base;
136 u64 now64;
137
138 rtcdrv = dev_get_drvdata(dev);
139 base = rtcdrv->base;
140
141 now64 = rtc_tm_to_time64(tm) * NSEC_PER_SEC;
142 gf_iowrite32((now64 >> 32), base + TIMER_TIME_HIGH);
143 gf_iowrite32(now64, base + TIMER_TIME_LOW);
144
145 return 0;
146 }
147
148 static const struct rtc_class_ops goldfish_rtc_ops = {
149 .read_time = goldfish_rtc_read_time,
150 .set_time = goldfish_rtc_set_time,
151 .read_alarm = goldfish_rtc_read_alarm,
152 .set_alarm = goldfish_rtc_set_alarm,
153 .alarm_irq_enable = goldfish_rtc_alarm_irq_enable
154 };
155
goldfish_rtc_probe(struct platform_device * pdev)156 static int goldfish_rtc_probe(struct platform_device *pdev)
157 {
158 struct goldfish_rtc *rtcdrv;
159 int err;
160
161 rtcdrv = devm_kzalloc(&pdev->dev, sizeof(*rtcdrv), GFP_KERNEL);
162 if (!rtcdrv)
163 return -ENOMEM;
164
165 platform_set_drvdata(pdev, rtcdrv);
166 rtcdrv->base = devm_platform_ioremap_resource(pdev, 0);
167 if (IS_ERR(rtcdrv->base))
168 return PTR_ERR(rtcdrv->base);
169
170 rtcdrv->irq = platform_get_irq(pdev, 0);
171 if (rtcdrv->irq < 0)
172 return -ENODEV;
173
174 rtcdrv->rtc = devm_rtc_allocate_device(&pdev->dev);
175 if (IS_ERR(rtcdrv->rtc))
176 return PTR_ERR(rtcdrv->rtc);
177
178 rtcdrv->rtc->ops = &goldfish_rtc_ops;
179 rtcdrv->rtc->range_max = U64_MAX / NSEC_PER_SEC;
180
181 err = devm_request_irq(&pdev->dev, rtcdrv->irq,
182 goldfish_rtc_interrupt,
183 0, pdev->name, rtcdrv);
184 if (err)
185 return err;
186
187 return devm_rtc_register_device(rtcdrv->rtc);
188 }
189
190 static const struct of_device_id goldfish_rtc_of_match[] = {
191 { .compatible = "google,goldfish-rtc", },
192 {},
193 };
194 MODULE_DEVICE_TABLE(of, goldfish_rtc_of_match);
195
196 static struct platform_driver goldfish_rtc = {
197 .probe = goldfish_rtc_probe,
198 .driver = {
199 .name = "goldfish_rtc",
200 .of_match_table = goldfish_rtc_of_match,
201 }
202 };
203
204 module_platform_driver(goldfish_rtc);
205
206 MODULE_LICENSE("GPL v2");
207