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_mmss64(struct device *dev, time64_t secs)
  74 {
  75         struct rtc_test_data *rtd = dev_get_drvdata(dev);
  76
  77         rtd->offset = secs - 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_mmss64 = test_rtc_set_mmss64,
  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         .read_alarm = test_rtc_read_alarm,
 104         .set_alarm = test_rtc_set_alarm,
 105         .set_mmss64 = test_rtc_set_mmss64,
 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         }
 137
 138         timer_setup(&rtd->alarm, test_rtc_alarm_handler, 0);
 139         rtd->alarm.expires = 0;
 140
 141         return 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         if ((err = platform_driver_register(&test_driver)))
 156                 return err;
 157
 158         err = -ENOMEM;
 159         for (i = 0; i < MAX_RTC_TEST; i++) {
 160                 pdev[i] = platform_device_alloc("rtc-test", i);
 161                 if (!pdev[i])
 162                         goto exit_free_mem;
 163         }
 164
 165         for (i = 0; i < MAX_RTC_TEST; i++) {
 166                 err = platform_device_add(pdev[i]);
 167                 if (err)
 168                         goto exit_device_del;
 169         }
 170
 171         return 0;
 172
 173 exit_device_del:
 174         for (; i > 0; i--)
 175                 platform_device_del(pdev[i - 1]);
 176
 177 exit_free_mem:
 178         for (i = 0; i < MAX_RTC_TEST; i++)
 179                 platform_device_put(pdev[i]);
 180
 181         platform_driver_unregister(&test_driver);
 182         return err;
 183 }
 184
 185 static void __exit test_exit(void)
 186 {
 187         int i;
 188
 189         for (i = 0; i < MAX_RTC_TEST; i++)
 190                 platform_device_unregister(pdev[i]);
 191
 192         platform_driver_unregister(&test_driver);
 193 }
 194
 195 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
 196 MODULE_DESCRIPTION("RTC test driver/device");
 197 MODULE_LICENSE("GPL v2");
 198
 199 module_init(test_init);
 200 module_exit(test_exit);