forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
201 lines
4.1 KiB
201 lines
4.1 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* An RTC test device/driver |
|
* Copyright (C) 2005 Tower Technologies |
|
* Author: Alessandro Zummo <[email protected]> |
|
*/ |
|
|
|
#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; |
|
|
|
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 devm_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 <[email protected]>"); |
|
MODULE_DESCRIPTION("RTC test driver/device"); |
|
MODULE_LICENSE("GPL v2"); |
|
|
|
module_init(test_init); |
|
module_exit(test_exit);
|
|
|