1 /* 2 * An RTC test device/driver 3 * Copyright (C) 2005 Tower Technologies 4 * Author: Alessandro Zummo <a.zummo@towertech.it> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 11 #include <linux/module.h> 12 #include <linux/err.h> 13 #include <linux/rtc.h> 14 #include <linux/platform_device.h> 15 16 #define MAX_RTC_TEST 3 17 18 struct rtc_test_data { 19 struct rtc_device *rtc; 20 time64_t offset; 21 struct timer_list alarm; 22 bool alarm_en; 23 }; 24 25 static struct platform_device *pdev[MAX_RTC_TEST]; 26 27 static int test_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) 28 { 29 struct rtc_test_data *rtd = dev_get_drvdata(dev); 30 time64_t alarm; 31 32 alarm = (rtd->alarm.expires - jiffies) / HZ; 33 alarm += ktime_get_real_seconds() + rtd->offset; 34 35 rtc_time64_to_tm(alarm, &alrm->time); 36 alrm->enabled = rtd->alarm_en; 37 38 return 0; 39 } 40 41 static int test_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 42 { 43 struct rtc_test_data *rtd = dev_get_drvdata(dev); 44 ktime_t timeout; 45 u64 expires; 46 47 timeout = rtc_tm_to_time64(&alrm->time) - ktime_get_real_seconds(); 48 timeout -= rtd->offset; 49 50 del_timer(&rtd->alarm); 51 52 expires = jiffies + timeout * HZ; 53 if (expires > U32_MAX) 54 expires = U32_MAX; 55 56 pr_err("ABE: %s +%d %s\n", __FILE__, __LINE__, __func__); 57 rtd->alarm.expires = expires; 58 59 if (alrm->enabled) 60 add_timer(&rtd->alarm); 61 62 rtd->alarm_en = alrm->enabled; 63 64 return 0; 65 } 66 67 static int test_rtc_read_time(struct device *dev, struct rtc_time *tm) 68 { 69 struct rtc_test_data *rtd = dev_get_drvdata(dev); 70 71 rtc_time64_to_tm(ktime_get_real_seconds() + rtd->offset, tm); 72 73 return 0; 74 } 75 76 static int test_rtc_set_mmss64(struct device *dev, time64_t secs) 77 { 78 struct rtc_test_data *rtd = dev_get_drvdata(dev); 79 80 rtd->offset = secs - ktime_get_real_seconds(); 81 82 return 0; 83 } 84 85 static int test_rtc_alarm_irq_enable(struct device *dev, unsigned int enable) 86 { 87 struct rtc_test_data *rtd = dev_get_drvdata(dev); 88 89 rtd->alarm_en = enable; 90 if (enable) 91 add_timer(&rtd->alarm); 92 else 93 del_timer(&rtd->alarm); 94 95 return 0; 96 } 97 98 static const struct rtc_class_ops test_rtc_ops_noalm = { 99 .read_time = test_rtc_read_time, 100 .set_mmss64 = test_rtc_set_mmss64, 101 .alarm_irq_enable = test_rtc_alarm_irq_enable, 102 }; 103 104 static const struct rtc_class_ops test_rtc_ops = { 105 .read_time = test_rtc_read_time, 106 .read_alarm = test_rtc_read_alarm, 107 .set_alarm = test_rtc_set_alarm, 108 .set_mmss64 = test_rtc_set_mmss64, 109 .alarm_irq_enable = test_rtc_alarm_irq_enable, 110 }; 111 112 static void test_rtc_alarm_handler(struct timer_list *t) 113 { 114 struct rtc_test_data *rtd = from_timer(rtd, t, alarm); 115 116 rtc_update_irq(rtd->rtc, 1, RTC_AF | RTC_IRQF); 117 } 118 119 static int test_probe(struct platform_device *plat_dev) 120 { 121 struct rtc_test_data *rtd; 122 123 rtd = devm_kzalloc(&plat_dev->dev, sizeof(*rtd), GFP_KERNEL); 124 if (!rtd) 125 return -ENOMEM; 126 127 platform_set_drvdata(plat_dev, rtd); 128 129 rtd->rtc = devm_rtc_allocate_device(&plat_dev->dev); 130 if (IS_ERR(rtd->rtc)) 131 return PTR_ERR(rtd->rtc); 132 133 switch (plat_dev->id) { 134 case 0: 135 rtd->rtc->ops = &test_rtc_ops_noalm; 136 break; 137 default: 138 rtd->rtc->ops = &test_rtc_ops; 139 } 140 141 timer_setup(&rtd->alarm, test_rtc_alarm_handler, 0); 142 rtd->alarm.expires = 0; 143 144 return rtc_register_device(rtd->rtc); 145 } 146 147 static struct platform_driver test_driver = { 148 .probe = test_probe, 149 .driver = { 150 .name = "rtc-test", 151 }, 152 }; 153 154 static int __init test_init(void) 155 { 156 int i, err; 157 158 if ((err = platform_driver_register(&test_driver))) 159 return err; 160 161 err = -ENOMEM; 162 for (i = 0; i < MAX_RTC_TEST; i++) { 163 pdev[i] = platform_device_alloc("rtc-test", i); 164 if (!pdev[i]) 165 goto exit_free_mem; 166 } 167 168 for (i = 0; i < MAX_RTC_TEST; i++) { 169 err = platform_device_add(pdev[i]); 170 if (err) 171 goto exit_device_del; 172 } 173 174 return 0; 175 176 exit_device_del: 177 for (; i > 0; i--) 178 platform_device_del(pdev[i - 1]); 179 180 exit_free_mem: 181 for (i = 0; i < MAX_RTC_TEST; i++) 182 platform_device_put(pdev[i]); 183 184 platform_driver_unregister(&test_driver); 185 return err; 186 } 187 188 static void __exit test_exit(void) 189 { 190 int i; 191 192 for (i = 0; i < MAX_RTC_TEST; i++) 193 platform_device_unregister(pdev[i]); 194 195 platform_driver_unregister(&test_driver); 196 } 197 198 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>"); 199 MODULE_DESCRIPTION("RTC test driver/device"); 200 MODULE_LICENSE("GPL"); 201 202 module_init(test_init); 203 module_exit(test_exit); 204