cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

rtc-test.c (4205B)

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