[linux-2.6-block.git] / drivers / rtc / rtc-goldfish.c

// SPDX-License-Identifier: GPL-2.0
/* drivers/rtc/rtc-goldfish.c
 *
 * Copyright (C) 2007 Google, Inc.
 * Copyright (C) 2017 Imagination Technologies Ltd.
 */

#include <linux/io.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/rtc.h>
#include <linux/goldfish.h>
#include <clocksource/timer-goldfish.h>

struct goldfish_rtc {
	void __iomem *base;
	int irq;
	struct rtc_device *rtc;
};

static int goldfish_rtc_read_alarm(struct device *dev,
				   struct rtc_wkalrm *alrm)
{
	u64 rtc_alarm;
	u64 rtc_alarm_low;
	u64 rtc_alarm_high;
	void __iomem *base;
	struct goldfish_rtc *rtcdrv;

	rtcdrv = dev_get_drvdata(dev);
	base = rtcdrv->base;

	rtc_alarm_low = gf_ioread32(base + TIMER_ALARM_LOW);
	rtc_alarm_high = gf_ioread32(base + TIMER_ALARM_HIGH);
	rtc_alarm = (rtc_alarm_high << 32) | rtc_alarm_low;

	do_div(rtc_alarm, NSEC_PER_SEC);
	memset(alrm, 0, sizeof(struct rtc_wkalrm));

	rtc_time64_to_tm(rtc_alarm, &alrm->time);

	if (gf_ioread32(base + TIMER_ALARM_STATUS))
		alrm->enabled = 1;
	else
		alrm->enabled = 0;

	return 0;
}

static int goldfish_rtc_set_alarm(struct device *dev,
				  struct rtc_wkalrm *alrm)
{
	struct goldfish_rtc *rtcdrv;
	u64 rtc_alarm64;
	u64 rtc_status_reg;
	void __iomem *base;

	rtcdrv = dev_get_drvdata(dev);
	base = rtcdrv->base;

	if (alrm->enabled) {
		rtc_alarm64 = rtc_tm_to_time64(&alrm->time) * NSEC_PER_SEC;
		gf_iowrite32((rtc_alarm64 >> 32), base + TIMER_ALARM_HIGH);
		gf_iowrite32(rtc_alarm64, base + TIMER_ALARM_LOW);
		gf_iowrite32(1, base + TIMER_IRQ_ENABLED);
	} else {
		/*
		 * if this function was called with enabled=0
		 * then it could mean that the application is
		 * trying to cancel an ongoing alarm
		 */
		rtc_status_reg = gf_ioread32(base + TIMER_ALARM_STATUS);
		if (rtc_status_reg)
			gf_iowrite32(1, base + TIMER_CLEAR_ALARM);
	}

	return 0;
}

static int goldfish_rtc_alarm_irq_enable(struct device *dev,
					 unsigned int enabled)
{
	void __iomem *base;
	struct goldfish_rtc *rtcdrv;

	rtcdrv = dev_get_drvdata(dev);
	base = rtcdrv->base;

	if (enabled)
		gf_iowrite32(1, base + TIMER_IRQ_ENABLED);
	else
		gf_iowrite32(0, base + TIMER_IRQ_ENABLED);

	return 0;
}

static irqreturn_t goldfish_rtc_interrupt(int irq, void *dev_id)
{
	struct goldfish_rtc *rtcdrv = dev_id;
	void __iomem *base = rtcdrv->base;

	gf_iowrite32(1, base + TIMER_CLEAR_INTERRUPT);

	rtc_update_irq(rtcdrv->rtc, 1, RTC_IRQF | RTC_AF);

	return IRQ_HANDLED;
}

static int goldfish_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct goldfish_rtc *rtcdrv;
	void __iomem *base;
	u64 time_high;
	u64 time_low;
	u64 time;

	rtcdrv = dev_get_drvdata(dev);
	base = rtcdrv->base;

	time_low = gf_ioread32(base + TIMER_TIME_LOW);
	time_high = gf_ioread32(base + TIMER_TIME_HIGH);
	time = (time_high << 32) | time_low;

	do_div(time, NSEC_PER_SEC);

	rtc_time64_to_tm(time, tm);

	return 0;
}

static int goldfish_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct goldfish_rtc *rtcdrv;
	void __iomem *base;
	u64 now64;

	rtcdrv = dev_get_drvdata(dev);
	base = rtcdrv->base;

	now64 = rtc_tm_to_time64(tm) * NSEC_PER_SEC;
	gf_iowrite32((now64 >> 32), base + TIMER_TIME_HIGH);
	gf_iowrite32(now64, base + TIMER_TIME_LOW);

	return 0;
}

static const struct rtc_class_ops goldfish_rtc_ops = {
	.read_time	= goldfish_rtc_read_time,
	.set_time	= goldfish_rtc_set_time,
	.read_alarm	= goldfish_rtc_read_alarm,
	.set_alarm	= goldfish_rtc_set_alarm,
	.alarm_irq_enable = goldfish_rtc_alarm_irq_enable
};

static int goldfish_rtc_probe(struct platform_device *pdev)
{
	struct goldfish_rtc *rtcdrv;
	int err;

	rtcdrv = devm_kzalloc(&pdev->dev, sizeof(*rtcdrv), GFP_KERNEL);
	if (!rtcdrv)
		return -ENOMEM;

	platform_set_drvdata(pdev, rtcdrv);
	rtcdrv->base = devm_platform_ioremap_resource(pdev, 0);
	if (IS_ERR(rtcdrv->base))
		return PTR_ERR(rtcdrv->base);

	rtcdrv->irq = platform_get_irq(pdev, 0);
	if (rtcdrv->irq < 0)
		return -ENODEV;

	rtcdrv->rtc = devm_rtc_allocate_device(&pdev->dev);
	if (IS_ERR(rtcdrv->rtc))
		return PTR_ERR(rtcdrv->rtc);

	rtcdrv->rtc->ops = &goldfish_rtc_ops;
	rtcdrv->rtc->range_max = U64_MAX / NSEC_PER_SEC;

	err = devm_request_irq(&pdev->dev, rtcdrv->irq,
			       goldfish_rtc_interrupt,
			       0, pdev->name, rtcdrv);
	if (err)
		return err;

	return devm_rtc_register_device(rtcdrv->rtc);
}

static const struct of_device_id goldfish_rtc_of_match[] = {
	{ .compatible = "google,goldfish-rtc", },
	{},
};
MODULE_DEVICE_TABLE(of, goldfish_rtc_of_match);

static struct platform_driver goldfish_rtc = {
	.probe = goldfish_rtc_probe,
	.driver = {
		.name = "goldfish_rtc",
		.of_match_table = goldfish_rtc_of_match,
	}
};

module_platform_driver(goldfish_rtc);

MODULE_LICENSE("GPL v2");
Commit	Line	Data
2be7f1b5	1	// SPDX-License-Identifier: GPL-2.0
f22d9cdc MD	2	/* drivers/rtc/rtc-goldfish.c
	3	*
	4	* Copyright (C) 2007 Google, Inc.
	5	* Copyright (C) 2017 Imagination Technologies Ltd.
f22d9cdc MD	6	*/
f22d9cdc MD	7
bd01386e	8	#include <linux/io.h>
f22d9cdc	9	#include <linux/module.h>
6a6ec8c1	10	#include <linux/of.h>
f22d9cdc MD	11	#include <linux/platform_device.h>
f22d9cdc MD	12	#include <linux/rtc.h>
3378c7f4	13	#include <linux/goldfish.h>
c92e7ef1	14	#include <clocksource/timer-goldfish.h>
f22d9cdc MD	15
	16	struct goldfish_rtc {
	17	void __iomem *base;
	18	int irq;
	19	struct rtc_device *rtc;
	20	};
	21
	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
3378c7f4 LV	34	rtc_alarm_low = gf_ioread32(base + TIMER_ALARM_LOW);
3378c7f4 LV	35	rtc_alarm_high = gf_ioread32(base + TIMER_ALARM_HIGH);
f22d9cdc MD	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
b509306d	41	rtc_time64_to_tm(rtc_alarm, &alrm->time);
f22d9cdc	42
3378c7f4	43	if (gf_ioread32(base + TIMER_ALARM_STATUS))
f22d9cdc MD	44	alrm->enabled = 1;
	45	else
	46	alrm->enabled = 0;
	47
	48	return 0;
	49	}
	50
	51	static int goldfish_rtc_set_alarm(struct device *dev,
	52	struct rtc_wkalrm *alrm)
	53	{
	54	struct goldfish_rtc *rtcdrv;
f22d9cdc MD	55	u64 rtc_alarm64;
	56	u64 rtc_status_reg;
	57	void __iomem *base;
f22d9cdc MD	58
	59	rtcdrv = dev_get_drvdata(dev);
	60	base = rtcdrv->base;
	61
	62	if (alrm->enabled) {
b509306d	63	rtc_alarm64 = rtc_tm_to_time64(&alrm->time) * NSEC_PER_SEC;
3378c7f4 LV	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);
f22d9cdc MD	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	*/
3378c7f4	73	rtc_status_reg = gf_ioread32(base + TIMER_ALARM_STATUS);
f22d9cdc	74	if (rtc_status_reg)
3378c7f4	75	gf_iowrite32(1, base + TIMER_CLEAR_ALARM);
f22d9cdc MD	76	}
f22d9cdc MD	77
b509306d	78	return 0;
f22d9cdc MD	79	}
	80
	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)
3378c7f4	91	gf_iowrite32(1, base + TIMER_IRQ_ENABLED);
f22d9cdc	92	else
3378c7f4	93	gf_iowrite32(0, base + TIMER_IRQ_ENABLED);
f22d9cdc MD	94
	95	return 0;
	96	}
	97
	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
3378c7f4	103	gf_iowrite32(1, base + TIMER_CLEAR_INTERRUPT);
f22d9cdc MD	104
	105	rtc_update_irq(rtcdrv->rtc, 1, RTC_IRQF \| RTC_AF);
	106
	107	return IRQ_HANDLED;
	108	}
	109
	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
3378c7f4 LV	121	time_low = gf_ioread32(base + TIMER_TIME_LOW);
3378c7f4 LV	122	time_high = gf_ioread32(base + TIMER_TIME_HIGH);
f22d9cdc MD	123	time = (time_high << 32) \| time_low;
	124
	125	do_div(time, NSEC_PER_SEC);
	126
b509306d	127	rtc_time64_to_tm(time, tm);
f22d9cdc MD	128
	129	return 0;
	130	}
	131
	132	static int goldfish_rtc_set_time(struct device dev, struct rtc_time tm)
	133	{
	134	struct goldfish_rtc *rtcdrv;
	135	void __iomem *base;
f22d9cdc	136	u64 now64;
f22d9cdc MD	137
	138	rtcdrv = dev_get_drvdata(dev);
	139	base = rtcdrv->base;
	140
b509306d	141	now64 = rtc_tm_to_time64(tm) * NSEC_PER_SEC;
3378c7f4 LV	142	gf_iowrite32((now64 >> 32), base + TIMER_TIME_HIGH);
3378c7f4 LV	143	gf_iowrite32(now64, base + TIMER_TIME_LOW);
f22d9cdc	144
b509306d	145	return 0;
f22d9cdc MD	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
	156	static int goldfish_rtc_probe(struct platform_device *pdev)
	157	{
	158	struct goldfish_rtc *rtcdrv;
f22d9cdc MD	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);
89576beb	166	rtcdrv->base = devm_platform_ioremap_resource(pdev, 0);
f22d9cdc	167	if (IS_ERR(rtcdrv->base))
f4c29a09	168	return PTR_ERR(rtcdrv->base);
f22d9cdc MD	169
	170	rtcdrv->irq = platform_get_irq(pdev, 0);
	171	if (rtcdrv->irq < 0)
	172	return -ENODEV;
	173
409b84e3	174	rtcdrv->rtc = devm_rtc_allocate_device(&pdev->dev);
f22d9cdc MD	175	if (IS_ERR(rtcdrv->rtc))
	176	return PTR_ERR(rtcdrv->rtc);
	177
409b84e3	178	rtcdrv->rtc->ops = &goldfish_rtc_ops;
5e2954fd	179	rtcdrv->rtc->range_max = U64_MAX / NSEC_PER_SEC;
409b84e3	180
f22d9cdc MD	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
fdcfd854	187	return devm_rtc_register_device(rtcdrv->rtc);
f22d9cdc MD	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);
82d632b8 JH	205
82d632b8 JH	206	MODULE_LICENSE("GPL v2");