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
 16struct goldfish_rtc {
 17	void __iomem *base;
 18	int irq;
 19	struct rtc_device *rtc;
 20};
 21
 22static 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
 51static 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
 81static 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
 98static 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
110static 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
132static 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
148static 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
156static 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
190static const struct of_device_id goldfish_rtc_of_match[] = {
191	{ .compatible = "google,goldfish-rtc", },
192	{},
193};
194MODULE_DEVICE_TABLE(of, goldfish_rtc_of_match);
195
196static 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
204module_platform_driver(goldfish_rtc);
205
206MODULE_DESCRIPTION("Android Goldfish Real Time Clock driver");
207MODULE_LICENSE("GPL v2");

 
  1/* drivers/rtc/rtc-goldfish.c
  2 *
  3 * Copyright (C) 2007 Google, Inc.
  4 * Copyright (C) 2017 Imagination Technologies Ltd.
  5 *
  6 * This software is licensed under the terms of the GNU General Public
  7 * License version 2, as published by the Free Software Foundation, and
  8 * may be copied, distributed, and modified under those terms.
  9 *
 10 * This program is distributed in the hope that it will be useful,
 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 * GNU General Public License for more details.
 14 *
 15 */
 16
 
 17#include <linux/module.h>
 
 18#include <linux/platform_device.h>
 19#include <linux/rtc.h>
 20#include <linux/io.h>
 21
 22#define TIMER_TIME_LOW		0x00	/* get low bits of current time  */
 23					/*   and update TIMER_TIME_HIGH  */
 24#define TIMER_TIME_HIGH	0x04	/* get high bits of time at last */
 25					/*   TIMER_TIME_LOW read         */
 26#define TIMER_ALARM_LOW	0x08	/* set low bits of alarm and     */
 27					/*   activate it                 */
 28#define TIMER_ALARM_HIGH	0x0c	/* set high bits of next alarm   */
 29#define TIMER_IRQ_ENABLED	0x10
 30#define TIMER_CLEAR_ALARM	0x14
 31#define TIMER_ALARM_STATUS	0x18
 32#define TIMER_CLEAR_INTERRUPT	0x1c
 33
 34struct goldfish_rtc {
 35	void __iomem *base;
 36	int irq;
 37	struct rtc_device *rtc;
 38};
 39
 40static int goldfish_rtc_read_alarm(struct device *dev,
 41				   struct rtc_wkalrm *alrm)
 42{
 43	u64 rtc_alarm;
 44	u64 rtc_alarm_low;
 45	u64 rtc_alarm_high;
 46	void __iomem *base;
 47	struct goldfish_rtc *rtcdrv;
 48
 49	rtcdrv = dev_get_drvdata(dev);
 50	base = rtcdrv->base;
 51
 52	rtc_alarm_low = readl(base + TIMER_ALARM_LOW);
 53	rtc_alarm_high = readl(base + TIMER_ALARM_HIGH);
 54	rtc_alarm = (rtc_alarm_high << 32) | rtc_alarm_low;
 55
 56	do_div(rtc_alarm, NSEC_PER_SEC);
 57	memset(alrm, 0, sizeof(struct rtc_wkalrm));
 58
 59	rtc_time_to_tm(rtc_alarm, &alrm->time);
 60
 61	if (readl(base + TIMER_ALARM_STATUS))
 62		alrm->enabled = 1;
 63	else
 64		alrm->enabled = 0;
 65
 66	return 0;
 67}
 68
 69static int goldfish_rtc_set_alarm(struct device *dev,
 70				  struct rtc_wkalrm *alrm)
 71{
 72	struct goldfish_rtc *rtcdrv;
 73	unsigned long rtc_alarm;
 74	u64 rtc_alarm64;
 75	u64 rtc_status_reg;
 76	void __iomem *base;
 77	int ret = 0;
 78
 79	rtcdrv = dev_get_drvdata(dev);
 80	base = rtcdrv->base;
 81
 82	if (alrm->enabled) {
 83		ret = rtc_tm_to_time(&alrm->time, &rtc_alarm);
 84		if (ret != 0)
 85			return ret;
 86
 87		rtc_alarm64 = rtc_alarm * NSEC_PER_SEC;
 88		writel((rtc_alarm64 >> 32), base + TIMER_ALARM_HIGH);
 89		writel(rtc_alarm64, base + TIMER_ALARM_LOW);
 90	} else {
 91		/*
 92		 * if this function was called with enabled=0
 93		 * then it could mean that the application is
 94		 * trying to cancel an ongoing alarm
 95		 */
 96		rtc_status_reg = readl(base + TIMER_ALARM_STATUS);
 97		if (rtc_status_reg)
 98			writel(1, base + TIMER_CLEAR_ALARM);
 99	}
100
101	return ret;
102}
103
104static int goldfish_rtc_alarm_irq_enable(struct device *dev,
105					 unsigned int enabled)
106{
107	void __iomem *base;
108	struct goldfish_rtc *rtcdrv;
109
110	rtcdrv = dev_get_drvdata(dev);
111	base = rtcdrv->base;
112
113	if (enabled)
114		writel(1, base + TIMER_IRQ_ENABLED);
115	else
116		writel(0, base + TIMER_IRQ_ENABLED);
117
118	return 0;
119}
120
121static irqreturn_t goldfish_rtc_interrupt(int irq, void *dev_id)
122{
123	struct goldfish_rtc *rtcdrv = dev_id;
124	void __iomem *base = rtcdrv->base;
125
126	writel(1, base + TIMER_CLEAR_INTERRUPT);
127
128	rtc_update_irq(rtcdrv->rtc, 1, RTC_IRQF | RTC_AF);
129
130	return IRQ_HANDLED;
131}
132
133static int goldfish_rtc_read_time(struct device *dev, struct rtc_time *tm)
134{
135	struct goldfish_rtc *rtcdrv;
136	void __iomem *base;
137	u64 time_high;
138	u64 time_low;
139	u64 time;
140
141	rtcdrv = dev_get_drvdata(dev);
142	base = rtcdrv->base;
143
144	time_low = readl(base + TIMER_TIME_LOW);
145	time_high = readl(base + TIMER_TIME_HIGH);
146	time = (time_high << 32) | time_low;
147
148	do_div(time, NSEC_PER_SEC);
149
150	rtc_time_to_tm(time, tm);
151
152	return 0;
153}
154
155static int goldfish_rtc_set_time(struct device *dev, struct rtc_time *tm)
156{
157	struct goldfish_rtc *rtcdrv;
158	void __iomem *base;
159	unsigned long now;
160	u64 now64;
161	int ret;
162
163	rtcdrv = dev_get_drvdata(dev);
164	base = rtcdrv->base;
165
166	ret = rtc_tm_to_time(tm, &now);
167	if (ret == 0) {
168		now64 = now * NSEC_PER_SEC;
169		writel((now64 >> 32), base + TIMER_TIME_HIGH);
170		writel(now64, base + TIMER_TIME_LOW);
171	}
172
173	return ret;
174}
175
176static const struct rtc_class_ops goldfish_rtc_ops = {
177	.read_time	= goldfish_rtc_read_time,
178	.set_time	= goldfish_rtc_set_time,
179	.read_alarm	= goldfish_rtc_read_alarm,
180	.set_alarm	= goldfish_rtc_set_alarm,
181	.alarm_irq_enable = goldfish_rtc_alarm_irq_enable
182};
183
184static int goldfish_rtc_probe(struct platform_device *pdev)
185{
186	struct goldfish_rtc *rtcdrv;
187	struct resource *r;
188	int err;
189
190	rtcdrv = devm_kzalloc(&pdev->dev, sizeof(*rtcdrv), GFP_KERNEL);
191	if (!rtcdrv)
192		return -ENOMEM;
193
194	platform_set_drvdata(pdev, rtcdrv);
195
196	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
197	if (!r)
198		return -ENODEV;
199
200	rtcdrv->base = devm_ioremap_resource(&pdev->dev, r);
201	if (IS_ERR(rtcdrv->base))
202		return -ENODEV;
203
204	rtcdrv->irq = platform_get_irq(pdev, 0);
205	if (rtcdrv->irq < 0)
206		return -ENODEV;
207
208	rtcdrv->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
209					       &goldfish_rtc_ops,
210					       THIS_MODULE);
211	if (IS_ERR(rtcdrv->rtc))
212		return PTR_ERR(rtcdrv->rtc);
213
 
 
 
214	err = devm_request_irq(&pdev->dev, rtcdrv->irq,
215			       goldfish_rtc_interrupt,
216			       0, pdev->name, rtcdrv);
217	if (err)
218		return err;
219
220	return 0;
221}
222
223static const struct of_device_id goldfish_rtc_of_match[] = {
224	{ .compatible = "google,goldfish-rtc", },
225	{},
226};
227MODULE_DEVICE_TABLE(of, goldfish_rtc_of_match);
228
229static struct platform_driver goldfish_rtc = {
230	.probe = goldfish_rtc_probe,
231	.driver = {
232		.name = "goldfish_rtc",
233		.of_match_table = goldfish_rtc_of_match,
234	}
235};
236
237module_platform_driver(goldfish_rtc);
238
 
239MODULE_LICENSE("GPL v2");