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         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
  63 static 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
  72 static 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
  81 static 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
  94 static 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
 100 static 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
 108 static 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
 115 static 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
 144 static struct platform_driver test_driver = {
 145         .probe  = test_probe,
 146         .driver = {
 147                 .name = "rtc-test",
 148         },
 149 };
 150
 151 static 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
 174 exit_device_del:
 175         for (; i > 0; i--)
 176                 platform_device_del(pdev[i - 1]);
 177
 178 exit_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
 186 static 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
 196 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
 197 MODULE_DESCRIPTION("RTC test driver/device");
 198 MODULE_LICENSE("GPL v2");
 199
 200 module_init(test_init);
 201 module_exit(test_exit);