drivers/rtc/rtc-test.c

   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
  15 struct rtc_test_data {
  16         struct rtc_device *rtc;
  17         time64_t offset;
  18         struct timer_list alarm;
  19         bool alarm_en;
  20 };
  21
  22 static struct platform_device *pdev[MAX_RTC_TEST];
  23
  24 static 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
  38 static 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         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
  61         return 0;
  62 }
  63
  64 static int test_rtc_read_time(struct device *dev, struct rtc_time *tm)
  65 {
  66         struct rtc_test_data *rtd = dev_get_drvdata(dev);
  67
  68         rtc_time64_to_tm(ktime_get_real_seconds() + rtd->offset, tm);
  69
  70         return 0;
  71 }
  72
  73 static int test_rtc_set_time(struct device *dev, struct rtc_time *tm)
  74 {
  75         struct rtc_test_data *rtd = dev_get_drvdata(dev);
  76
  77         rtd->offset = rtc_tm_to_time64(tm) - ktime_get_real_seconds();
  78
  79         return 0;
  80 }
  81
  82 static int test_rtc_alarm_irq_enable(struct device *dev, unsigned int enable)
  83 {
  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
  92         return 0;
  93 }
  94
  95 static const struct rtc_class_ops test_rtc_ops_noalm = {
  96         .read_time = test_rtc_read_time,
  97         .set_time = test_rtc_set_time,
  98         .alarm_irq_enable = test_rtc_alarm_irq_enable,
  99 };
 100
 101 static const struct rtc_class_ops test_rtc_ops = {
 102         .read_time = test_rtc_read_time,
 103         .set_time = test_rtc_set_time,
 104         .read_alarm = test_rtc_read_alarm,
 105         .set_alarm = test_rtc_set_alarm,
 106         .alarm_irq_enable = test_rtc_alarm_irq_enable,
 107 };
 108
 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
 116 static int test_probe(struct platform_device *plat_dev)
 117 {
 118         struct rtc_test_data *rtd;
 119
 120         rtd = devm_kzalloc(&plat_dev->dev, sizeof(*rtd), GFP_KERNEL);
 121         if (!rtd)
 122                 return -ENOMEM;
 123
 124         platform_set_drvdata(plat_dev, rtd);
 125
 126         rtd->rtc = devm_rtc_allocate_device(&plat_dev->dev);
 127         if (IS_ERR(rtd->rtc))
 128                 return PTR_ERR(rtd->rtc);
 129
 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;
 136                 device_init_wakeup(&plat_dev->dev, 1);
 137         }
 138
 139         timer_setup(&rtd->alarm, test_rtc_alarm_handler, 0);
 140         rtd->alarm.expires = 0;
 141
 142         return rtc_register_device(rtd->rtc);
 143 }
 144
 145 static struct platform_driver test_driver = {
 146         .probe  = test_probe,
 147         .driver = {
 148                 .name = "rtc-test",
 149         },
 150 };
 151
 152 static int __init test_init(void)
 153 {
 154         int i, err;
 155
 156         err = platform_driver_register(&test_driver);
 157         if (err)
 158                 return err;
 159
 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;
 165         }
 166
 167         for (i = 0; i < MAX_RTC_TEST; i++) {
 168                 err = platform_device_add(pdev[i]);
 169                 if (err)
 170                         goto exit_device_del;
 171         }
 172
 173         return 0;
 174
 175 exit_device_del:
 176         for (; i > 0; i--)
 177                 platform_device_del(pdev[i - 1]);
 178
 179 exit_free_mem:
 180         for (i = 0; i < MAX_RTC_TEST; i++)
 181                 platform_device_put(pdev[i]);
 182
 183         platform_driver_unregister(&test_driver);
 184         return err;
 185 }
 186
 187 static void __exit test_exit(void)
 188 {
 189         int i;
 190
 191         for (i = 0; i < MAX_RTC_TEST; i++)
 192                 platform_device_unregister(pdev[i]);
 193
 194         platform_driver_unregister(&test_driver);
 195 }
 196
 197 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
 198 MODULE_DESCRIPTION("RTC test driver/device");
 199 MODULE_LICENSE("GPL v2");
 200
 201 module_init(test_init);
 202 module_exit(test_exit);