1 /* 2 * RTC subsystem, base class 3 * 4 * Copyright (C) 2005 Tower Technologies 5 * Author: Alessandro Zummo <a.zummo@towertech.it> 6 * 7 * class skeleton from drivers/hwmon/hwmon.c 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 */ 13 14 #include <linux/module.h> 15 #include <linux/rtc.h> 16 #include <linux/kdev_t.h> 17 #include <linux/idr.h> 18 #include <linux/slab.h> 19 #include <linux/workqueue.h> 20 21 #include "rtc-core.h" 22 23 24 static DEFINE_IDA(rtc_ida); 25 struct class *rtc_class; 26 27 static void rtc_device_release(struct device *dev) 28 { 29 struct rtc_device *rtc = to_rtc_device(dev); 30 ida_simple_remove(&rtc_ida, rtc->id); 31 kfree(rtc); 32 } 33 34 #if defined(CONFIG_PM) && defined(CONFIG_RTC_HCTOSYS_DEVICE) 35 36 /* 37 * On suspend(), measure the delta between one RTC and the 38 * system's wall clock; restore it on resume(). 39 */ 40 41 static struct timespec old_rtc, old_system, old_delta; 42 43 44 static int rtc_suspend(struct device *dev, pm_message_t mesg) 45 { 46 struct rtc_device *rtc = to_rtc_device(dev); 47 struct rtc_time tm; 48 struct timespec delta, delta_delta; 49 if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0) 50 return 0; 51 52 /* snapshot the current RTC and system time at suspend*/ 53 rtc_read_time(rtc, &tm); 54 getnstimeofday(&old_system); 55 rtc_tm_to_time(&tm, &old_rtc.tv_sec); 56 57 58 /* 59 * To avoid drift caused by repeated suspend/resumes, 60 * which each can add ~1 second drift error, 61 * try to compensate so the difference in system time 62 * and rtc time stays close to constant. 63 */ 64 delta = timespec_sub(old_system, old_rtc); 65 delta_delta = timespec_sub(delta, old_delta); 66 if (abs(delta_delta.tv_sec) >= 2) { 67 /* 68 * if delta_delta is too large, assume time correction 69 * has occured and set old_delta to the current delta. 70 */ 71 old_delta = delta; 72 } else { 73 /* Otherwise try to adjust old_system to compensate */ 74 old_system = timespec_sub(old_system, delta_delta); 75 } 76 77 return 0; 78 } 79 80 static int rtc_resume(struct device *dev) 81 { 82 struct rtc_device *rtc = to_rtc_device(dev); 83 struct rtc_time tm; 84 struct timespec new_system, new_rtc; 85 struct timespec sleep_time; 86 87 if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0) 88 return 0; 89 90 /* snapshot the current rtc and system time at resume */ 91 getnstimeofday(&new_system); 92 rtc_read_time(rtc, &tm); 93 if (rtc_valid_tm(&tm) != 0) { 94 pr_debug("%s: bogus resume time\n", dev_name(&rtc->dev)); 95 return 0; 96 } 97 rtc_tm_to_time(&tm, &new_rtc.tv_sec); 98 new_rtc.tv_nsec = 0; 99 100 if (new_rtc.tv_sec <= old_rtc.tv_sec) { 101 if (new_rtc.tv_sec < old_rtc.tv_sec) 102 pr_debug("%s: time travel!\n", dev_name(&rtc->dev)); 103 return 0; 104 } 105 106 /* calculate the RTC time delta (sleep time)*/ 107 sleep_time = timespec_sub(new_rtc, old_rtc); 108 109 /* 110 * Since these RTC suspend/resume handlers are not called 111 * at the very end of suspend or the start of resume, 112 * some run-time may pass on either sides of the sleep time 113 * so subtract kernel run-time between rtc_suspend to rtc_resume 114 * to keep things accurate. 115 */ 116 sleep_time = timespec_sub(sleep_time, 117 timespec_sub(new_system, old_system)); 118 119 timekeeping_inject_sleeptime(&sleep_time); 120 return 0; 121 } 122 123 #else 124 #define rtc_suspend NULL 125 #define rtc_resume NULL 126 #endif 127 128 129 /** 130 * rtc_device_register - register w/ RTC class 131 * @dev: the device to register 132 * 133 * rtc_device_unregister() must be called when the class device is no 134 * longer needed. 135 * 136 * Returns the pointer to the new struct class device. 137 */ 138 struct rtc_device *rtc_device_register(const char *name, struct device *dev, 139 const struct rtc_class_ops *ops, 140 struct module *owner) 141 { 142 struct rtc_device *rtc; 143 struct rtc_wkalrm alrm; 144 int id, err; 145 146 id = ida_simple_get(&rtc_ida, 0, 0, GFP_KERNEL); 147 if (id < 0) { 148 err = id; 149 goto exit; 150 } 151 152 rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL); 153 if (rtc == NULL) { 154 err = -ENOMEM; 155 goto exit_ida; 156 } 157 158 rtc->id = id; 159 rtc->ops = ops; 160 rtc->owner = owner; 161 rtc->irq_freq = 1; 162 rtc->max_user_freq = 64; 163 rtc->dev.parent = dev; 164 rtc->dev.class = rtc_class; 165 rtc->dev.release = rtc_device_release; 166 167 mutex_init(&rtc->ops_lock); 168 spin_lock_init(&rtc->irq_lock); 169 spin_lock_init(&rtc->irq_task_lock); 170 init_waitqueue_head(&rtc->irq_queue); 171 172 /* Init timerqueue */ 173 timerqueue_init_head(&rtc->timerqueue); 174 INIT_WORK(&rtc->irqwork, rtc_timer_do_work); 175 /* Init aie timer */ 176 rtc_timer_init(&rtc->aie_timer, rtc_aie_update_irq, (void *)rtc); 177 /* Init uie timer */ 178 rtc_timer_init(&rtc->uie_rtctimer, rtc_uie_update_irq, (void *)rtc); 179 /* Init pie timer */ 180 hrtimer_init(&rtc->pie_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 181 rtc->pie_timer.function = rtc_pie_update_irq; 182 rtc->pie_enabled = 0; 183 184 /* Check to see if there is an ALARM already set in hw */ 185 err = __rtc_read_alarm(rtc, &alrm); 186 187 if (!err && !rtc_valid_tm(&alrm.time)) 188 rtc_initialize_alarm(rtc, &alrm); 189 190 strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE); 191 dev_set_name(&rtc->dev, "rtc%d", id); 192 193 rtc_dev_prepare(rtc); 194 195 err = device_register(&rtc->dev); 196 if (err) { 197 put_device(&rtc->dev); 198 goto exit_kfree; 199 } 200 201 rtc_dev_add_device(rtc); 202 rtc_sysfs_add_device(rtc); 203 rtc_proc_add_device(rtc); 204 205 dev_info(dev, "rtc core: registered %s as %s\n", 206 rtc->name, dev_name(&rtc->dev)); 207 208 return rtc; 209 210 exit_kfree: 211 kfree(rtc); 212 213 exit_ida: 214 ida_simple_remove(&rtc_ida, id); 215 216 exit: 217 dev_err(dev, "rtc core: unable to register %s, err = %d\n", 218 name, err); 219 return ERR_PTR(err); 220 } 221 EXPORT_SYMBOL_GPL(rtc_device_register); 222 223 224 /** 225 * rtc_device_unregister - removes the previously registered RTC class device 226 * 227 * @rtc: the RTC class device to destroy 228 */ 229 void rtc_device_unregister(struct rtc_device *rtc) 230 { 231 if (get_device(&rtc->dev) != NULL) { 232 mutex_lock(&rtc->ops_lock); 233 /* remove innards of this RTC, then disable it, before 234 * letting any rtc_class_open() users access it again 235 */ 236 rtc_sysfs_del_device(rtc); 237 rtc_dev_del_device(rtc); 238 rtc_proc_del_device(rtc); 239 device_unregister(&rtc->dev); 240 rtc->ops = NULL; 241 mutex_unlock(&rtc->ops_lock); 242 put_device(&rtc->dev); 243 } 244 } 245 EXPORT_SYMBOL_GPL(rtc_device_unregister); 246 247 static int __init rtc_init(void) 248 { 249 rtc_class = class_create(THIS_MODULE, "rtc"); 250 if (IS_ERR(rtc_class)) { 251 printk(KERN_ERR "%s: couldn't create class\n", __FILE__); 252 return PTR_ERR(rtc_class); 253 } 254 rtc_class->suspend = rtc_suspend; 255 rtc_class->resume = rtc_resume; 256 rtc_dev_init(); 257 rtc_sysfs_init(rtc_class); 258 return 0; 259 } 260 261 static void __exit rtc_exit(void) 262 { 263 rtc_dev_exit(); 264 class_destroy(rtc_class); 265 ida_destroy(&rtc_ida); 266 } 267 268 subsys_initcall(rtc_init); 269 module_exit(rtc_exit); 270 271 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>"); 272 MODULE_DESCRIPTION("RTC class support"); 273 MODULE_LICENSE("GPL"); 274