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

// SPDX-License-Identifier: GPL-2.0
/*
 * An RTC test device/driver
 * Copyright (C) 2005 Tower Technologies
 * Author: Alessandro Zummo <a.zummo@towertech.it>
 */

#include <linux/module.h>
#include <linux/err.h>
#include <linux/rtc.h>
#include <linux/platform_device.h>

#define MAX_RTC_TEST 3

struct rtc_test_data {
	struct rtc_device *rtc;
	time64_t offset;
	struct timer_list alarm;
	bool alarm_en;
};

static struct platform_device *pdev[MAX_RTC_TEST];

static int test_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct rtc_test_data *rtd = dev_get_drvdata(dev);
	time64_t alarm;

	alarm = (rtd->alarm.expires - jiffies) / HZ;
	alarm += ktime_get_real_seconds() + rtd->offset;

	rtc_time64_to_tm(alarm, &alrm->time);
	alrm->enabled = rtd->alarm_en;

	return 0;
}

static int test_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct rtc_test_data *rtd = dev_get_drvdata(dev);
	ktime_t timeout;
	u64 expires;

	timeout = rtc_tm_to_time64(&alrm->time) - ktime_get_real_seconds();
	timeout -= rtd->offset;

	del_timer(&rtd->alarm);

	expires = jiffies + timeout * HZ;
	if (expires > U32_MAX)
		expires = U32_MAX;

	pr_err("ABE: %s +%d %s\n", __FILE__, __LINE__, __func__);
	rtd->alarm.expires = expires;

	if (alrm->enabled)
		add_timer(&rtd->alarm);

	rtd->alarm_en = alrm->enabled;

	return 0;
}

static int test_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct rtc_test_data *rtd = dev_get_drvdata(dev);

	rtc_time64_to_tm(ktime_get_real_seconds() + rtd->offset, tm);

	return 0;
}

static int test_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct rtc_test_data *rtd = dev_get_drvdata(dev);

	rtd->offset = rtc_tm_to_time64(tm) - ktime_get_real_seconds();

	return 0;
}

static int test_rtc_alarm_irq_enable(struct device *dev, unsigned int enable)
{
	struct rtc_test_data *rtd = dev_get_drvdata(dev);

	rtd->alarm_en = enable;
	if (enable)
		add_timer(&rtd->alarm);
	else
		del_timer(&rtd->alarm);

	return 0;
}

static const struct rtc_class_ops test_rtc_ops_noalm = {
	.read_time = test_rtc_read_time,
	.set_time = test_rtc_set_time,
	.alarm_irq_enable = test_rtc_alarm_irq_enable,
};

static const struct rtc_class_ops test_rtc_ops = {
	.read_time = test_rtc_read_time,
	.set_time = test_rtc_set_time,
	.read_alarm = test_rtc_read_alarm,
	.set_alarm = test_rtc_set_alarm,
	.alarm_irq_enable = test_rtc_alarm_irq_enable,
};

static void test_rtc_alarm_handler(struct timer_list *t)
{
	struct rtc_test_data *rtd = from_timer(rtd, t, alarm);

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

static int test_probe(struct platform_device *plat_dev)
{
	struct rtc_test_data *rtd;

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

	platform_set_drvdata(plat_dev, rtd);

	rtd->rtc = devm_rtc_allocate_device(&plat_dev->dev);
	if (IS_ERR(rtd->rtc))
		return PTR_ERR(rtd->rtc);

	switch (plat_dev->id) {
	case 0:
		rtd->rtc->ops = &test_rtc_ops_noalm;
		break;
	default:
		rtd->rtc->ops = &test_rtc_ops;
		device_init_wakeup(&plat_dev->dev, 1);
	}

	timer_setup(&rtd->alarm, test_rtc_alarm_handler, 0);
	rtd->alarm.expires = 0;

	return rtc_register_device(rtd->rtc);
}

static struct platform_driver test_driver = {
	.probe	= test_probe,
	.driver = {
		.name = "rtc-test",
	},
};

static int __init test_init(void)
{
	int i, err;

	err = platform_driver_register(&test_driver);
	if (err)
		return err;

	err = -ENOMEM;
	for (i = 0; i < MAX_RTC_TEST; i++) {
		pdev[i] = platform_device_alloc("rtc-test", i);
		if (!pdev[i])
			goto exit_free_mem;
	}

	for (i = 0; i < MAX_RTC_TEST; i++) {
		err = platform_device_add(pdev[i]);
		if (err)
			goto exit_device_del;
	}

	return 0;

exit_device_del:
	for (; i > 0; i--)
		platform_device_del(pdev[i - 1]);

exit_free_mem:
	for (i = 0; i < MAX_RTC_TEST; i++)
		platform_device_put(pdev[i]);

	platform_driver_unregister(&test_driver);
	return err;
}

static void __exit test_exit(void)
{
	int i;

	for (i = 0; i < MAX_RTC_TEST; i++)
		platform_device_unregister(pdev[i]);

	platform_driver_unregister(&test_driver);
}

MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
MODULE_DESCRIPTION("RTC test driver/device");
MODULE_LICENSE("GPL v2");

module_init(test_init);
module_exit(test_exit);
Commit	Line	Data
c7080e20	1	// SPDX-License-Identifier: GPL-2.0
a95579cd AZ	2	/*
	3	* An RTC test device/driver
	4	* Copyright (C) 2005 Tower Technologies
	5	* Author: Alessandro Zummo <a.zummo@towertech.it>
a95579cd AZ	6	*/
	7
	8	#include <linux/module.h>
	9	#include <linux/err.h>
	10	#include <linux/rtc.h>
	11	#include <linux/platform_device.h>
	12
5b257571 AB	13	#define MAX_RTC_TEST 3
5b257571 AB	14
4dc2403b AB	15	struct rtc_test_data {
	16	struct rtc_device *rtc;
	17	time64_t offset;
8be09029 AB	18	struct timer_list alarm;
8be09029 AB	19	bool alarm_en;
4dc2403b AB	20	};
4dc2403b AB	21
2b4f07e9	22	static struct platform_device *pdev[MAX_RTC_TEST];
a95579cd	23
8be09029	24	static int test_rtc_read_alarm(struct device dev, struct rtc_wkalrm alrm)
a95579cd	25	{
8be09029 AB	26	struct rtc_test_data *rtd = dev_get_drvdata(dev);
	27	time64_t alarm;
	28
	29	alarm = (rtd->alarm.expires - jiffies) / HZ;
	30	alarm += ktime_get_real_seconds() + rtd->offset;
	31
	32	rtc_time64_to_tm(alarm, &alrm->time);
	33	alrm->enabled = rtd->alarm_en;
	34
a95579cd AZ	35	return 0;
	36	}
	37
8be09029	38	static int test_rtc_set_alarm(struct device dev, struct rtc_wkalrm alrm)
a95579cd	39	{
8be09029 AB	40	struct rtc_test_data *rtd = dev_get_drvdata(dev);
	41	ktime_t timeout;
	42	u64 expires;
	43
	44	timeout = rtc_tm_to_time64(&alrm->time) - ktime_get_real_seconds();
	45	timeout -= rtd->offset;
	46
	47	del_timer(&rtd->alarm);
	48
	49	expires = jiffies + timeout * HZ;
	50	if (expires > U32_MAX)
	51	expires = U32_MAX;
	52
	53	pr_err("ABE: %s +%d %s\n", __FILE__, __LINE__, __func__);
	54	rtd->alarm.expires = expires;
	55
	56	if (alrm->enabled)
	57	add_timer(&rtd->alarm);
	58
	59	rtd->alarm_en = alrm->enabled;
	60
a95579cd AZ	61	return 0;
	62	}
	63
4dc2403b	64	static int test_rtc_read_time(struct device dev, struct rtc_time tm)
a95579cd	65	{
4dc2403b AB	66	struct rtc_test_data *rtd = dev_get_drvdata(dev);
	67
	68	rtc_time64_to_tm(ktime_get_real_seconds() + rtd->offset, tm);
	69
4d644ab8 XP	70	return 0;
	71	}
	72
43dae505	73	static int test_rtc_set_time(struct device dev, struct rtc_time tm)
4d644ab8	74	{
4dc2403b AB	75	struct rtc_test_data *rtd = dev_get_drvdata(dev);
4dc2403b AB	76
43dae505	77	rtd->offset = rtc_tm_to_time64(tm) - ktime_get_real_seconds();
4dc2403b	78
a95579cd AZ	79	return 0;
	80	}
	81
16380c15	82	static int test_rtc_alarm_irq_enable(struct device *dev, unsigned int enable)
a95579cd	83	{
8be09029 AB	84	struct rtc_test_data *rtd = dev_get_drvdata(dev);
	85
	86	rtd->alarm_en = enable;
	87	if (enable)
	88	add_timer(&rtd->alarm);
	89	else
	90	del_timer(&rtd->alarm);
	91
16380c15	92	return 0;
a95579cd AZ	93	}
a95579cd AZ	94
1928906d AB	95	static const struct rtc_class_ops test_rtc_ops_noalm = {
1928906d AB	96	.read_time = test_rtc_read_time,
43dae505	97	.set_time = test_rtc_set_time,
1928906d AB	98	.alarm_irq_enable = test_rtc_alarm_irq_enable,
	99	};
	100
78417682	101	static const struct rtc_class_ops test_rtc_ops = {
a95579cd	102	.read_time = test_rtc_read_time,
43dae505	103	.set_time = test_rtc_set_time,
a95579cd AZ	104	.read_alarm = test_rtc_read_alarm,
a95579cd AZ	105	.set_alarm = test_rtc_set_alarm,
16380c15	106	.alarm_irq_enable = test_rtc_alarm_irq_enable,
a95579cd AZ	107	};
a95579cd AZ	108
8be09029 AB	109	static void test_rtc_alarm_handler(struct timer_list *t)
	110	{
	111	struct rtc_test_data *rtd = from_timer(rtd, t, alarm);
	112
	113	rtc_update_irq(rtd->rtc, 1, RTC_AF \| RTC_IRQF);
	114	}
	115
a95579cd AZ	116	static int test_probe(struct platform_device *plat_dev)
a95579cd AZ	117	{
4dc2403b	118	struct rtc_test_data *rtd;
dd8d8137	119
4dc2403b AB	120	rtd = devm_kzalloc(&plat_dev->dev, sizeof(*rtd), GFP_KERNEL);
	121	if (!rtd)
	122	return -ENOMEM;
91046a8a	123
4dc2403b	124	platform_set_drvdata(plat_dev, rtd);
a95579cd	125
0b472ad2	126	rtd->rtc = devm_rtc_allocate_device(&plat_dev->dev);
4dc2403b AB	127	if (IS_ERR(rtd->rtc))
4dc2403b AB	128	return PTR_ERR(rtd->rtc);
a95579cd	129
1928906d AB	130	switch (plat_dev->id) {
	131	case 0:
	132	rtd->rtc->ops = &test_rtc_ops_noalm;
	133	break;
	134	default:
	135	rtd->rtc->ops = &test_rtc_ops;
c19623db	136	device_init_wakeup(&plat_dev->dev, 1);
1928906d	137	}
0b472ad2	138
8be09029 AB	139	timer_setup(&rtd->alarm, test_rtc_alarm_handler, 0);
	140	rtd->alarm.expires = 0;
	141
0b472ad2	142	return rtc_register_device(rtd->rtc);
a95579cd AZ	143	}
a95579cd AZ	144
c4646528	145	static struct platform_driver test_driver = {
a95579cd	146	.probe = test_probe,
a95579cd AZ	147	.driver = {
a95579cd AZ	148	.name = "rtc-test",
a95579cd AZ	149	},
	150	};
	151
	152	static int __init test_init(void)
	153	{
5b257571	154	int i, err;
a95579cd	155
540a11d8 AB	156	err = platform_driver_register(&test_driver);
540a11d8 AB	157	if (err)
a95579cd AZ	158	return err;
a95579cd AZ	159
5b257571 AB	160	err = -ENOMEM;
	161	for (i = 0; i < MAX_RTC_TEST; i++) {
	162	pdev[i] = platform_device_alloc("rtc-test", i);
	163	if (!pdev[i])
	164	goto exit_free_mem;
a95579cd AZ	165	}
a95579cd AZ	166
5b257571 AB	167	for (i = 0; i < MAX_RTC_TEST; i++) {
	168	err = platform_device_add(pdev[i]);
	169	if (err)
	170	goto exit_device_del;
a95579cd AZ	171	}
a95579cd AZ	172
a95579cd AZ	173	return 0;
a95579cd AZ	174
5b257571 AB	175	exit_device_del:
	176	for (; i > 0; i--)
	177	platform_device_del(pdev[i - 1]);
a95579cd	178
5b257571 AB	179	exit_free_mem:
	180	for (i = 0; i < MAX_RTC_TEST; i++)
	181	platform_device_put(pdev[i]);
a95579cd	182
c4646528	183	platform_driver_unregister(&test_driver);
a95579cd AZ	184	return err;
	185	}
	186
	187	static void __exit test_exit(void)
	188	{
5b257571 AB	189	int i;
	190
	191	for (i = 0; i < MAX_RTC_TEST; i++)
	192	platform_device_unregister(pdev[i]);
	193
c4646528	194	platform_driver_unregister(&test_driver);
a95579cd AZ	195	}
	196
	197	MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
	198	MODULE_DESCRIPTION("RTC test driver/device");
fd13c930	199	MODULE_LICENSE("GPL v2");
a95579cd AZ	200
	201	module_init(test_init);
	202	module_exit(test_exit);