Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
class.c
Go to the documentation of this file.
1 /*
2  * RTC subsystem, base class
3  *
4  * Copyright (C) 2005 Tower Technologies
5  * Author: Alessandro Zummo <[email protected]>
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 #ifdef CONFIG_RTC_HCTOSYS_DEVICE
35 /* Result of the last RTC to system clock attempt. */
36 int rtc_hctosys_ret = -ENODEV;
37 #endif
38 
39 #if defined(CONFIG_PM) && defined(CONFIG_RTC_HCTOSYS_DEVICE)
40 /*
41  * On suspend(), measure the delta between one RTC and the
42  * system's wall clock; restore it on resume().
43  */
44 
45 static struct timespec old_rtc, old_system, old_delta;
46 
47 
48 static int rtc_suspend(struct device *dev, pm_message_t mesg)
49 {
50  struct rtc_device *rtc = to_rtc_device(dev);
51  struct rtc_time tm;
52  struct timespec delta, delta_delta;
53  if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
54  return 0;
55 
56  /* snapshot the current RTC and system time at suspend*/
57  rtc_read_time(rtc, &tm);
58  getnstimeofday(&old_system);
59  rtc_tm_to_time(&tm, &old_rtc.tv_sec);
60 
61 
62  /*
63  * To avoid drift caused by repeated suspend/resumes,
64  * which each can add ~1 second drift error,
65  * try to compensate so the difference in system time
66  * and rtc time stays close to constant.
67  */
68  delta = timespec_sub(old_system, old_rtc);
69  delta_delta = timespec_sub(delta, old_delta);
70  if (delta_delta.tv_sec < -2 || delta_delta.tv_sec >= 2) {
71  /*
72  * if delta_delta is too large, assume time correction
73  * has occured and set old_delta to the current delta.
74  */
75  old_delta = delta;
76  } else {
77  /* Otherwise try to adjust old_system to compensate */
78  old_system = timespec_sub(old_system, delta_delta);
79  }
80 
81  return 0;
82 }
83 
84 static int rtc_resume(struct device *dev)
85 {
86  struct rtc_device *rtc = to_rtc_device(dev);
87  struct rtc_time tm;
88  struct timespec new_system, new_rtc;
89  struct timespec sleep_time;
90 
92  if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
93  return 0;
94 
95  /* snapshot the current rtc and system time at resume */
96  getnstimeofday(&new_system);
97  rtc_read_time(rtc, &tm);
98  if (rtc_valid_tm(&tm) != 0) {
99  pr_debug("%s: bogus resume time\n", dev_name(&rtc->dev));
100  return 0;
101  }
102  rtc_tm_to_time(&tm, &new_rtc.tv_sec);
103  new_rtc.tv_nsec = 0;
104 
105  if (new_rtc.tv_sec < old_rtc.tv_sec) {
106  pr_debug("%s: time travel!\n", dev_name(&rtc->dev));
107  return 0;
108  }
109 
110  /* calculate the RTC time delta (sleep time)*/
111  sleep_time = timespec_sub(new_rtc, old_rtc);
112 
113  /*
114  * Since these RTC suspend/resume handlers are not called
115  * at the very end of suspend or the start of resume,
116  * some run-time may pass on either sides of the sleep time
117  * so subtract kernel run-time between rtc_suspend to rtc_resume
118  * to keep things accurate.
119  */
120  sleep_time = timespec_sub(sleep_time,
121  timespec_sub(new_system, old_system));
122 
123  if (sleep_time.tv_sec >= 0)
124  timekeeping_inject_sleeptime(&sleep_time);
125  rtc_hctosys_ret = 0;
126  return 0;
127 }
128 
129 #else
130 #define rtc_suspend NULL
131 #define rtc_resume NULL
132 #endif
133 
134 
144 struct rtc_device *rtc_device_register(const char *name, struct device *dev,
145  const struct rtc_class_ops *ops,
146  struct module *owner)
147 {
148  struct rtc_device *rtc;
149  struct rtc_wkalrm alrm;
150  int id, err;
151 
152  id = ida_simple_get(&rtc_ida, 0, 0, GFP_KERNEL);
153  if (id < 0) {
154  err = id;
155  goto exit;
156  }
157 
158  rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL);
159  if (rtc == NULL) {
160  err = -ENOMEM;
161  goto exit_ida;
162  }
163 
164  rtc->id = id;
165  rtc->ops = ops;
166  rtc->owner = owner;
167  rtc->irq_freq = 1;
168  rtc->max_user_freq = 64;
169  rtc->dev.parent = dev;
170  rtc->dev.class = rtc_class;
171  rtc->dev.release = rtc_device_release;
172 
173  mutex_init(&rtc->ops_lock);
174  spin_lock_init(&rtc->irq_lock);
177 
178  /* Init timerqueue */
179  timerqueue_init_head(&rtc->timerqueue);
181  /* Init aie timer */
182  rtc_timer_init(&rtc->aie_timer, rtc_aie_update_irq, (void *)rtc);
183  /* Init uie timer */
184  rtc_timer_init(&rtc->uie_rtctimer, rtc_uie_update_irq, (void *)rtc);
185  /* Init pie timer */
187  rtc->pie_timer.function = rtc_pie_update_irq;
188  rtc->pie_enabled = 0;
189 
190  /* Check to see if there is an ALARM already set in hw */
191  err = __rtc_read_alarm(rtc, &alrm);
192 
193  if (!err && !rtc_valid_tm(&alrm.time))
194  rtc_initialize_alarm(rtc, &alrm);
195 
196  strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE);
197  dev_set_name(&rtc->dev, "rtc%d", id);
198 
199  rtc_dev_prepare(rtc);
200 
201  err = device_register(&rtc->dev);
202  if (err) {
203  put_device(&rtc->dev);
204  goto exit_kfree;
205  }
206 
207  rtc_dev_add_device(rtc);
209  rtc_proc_add_device(rtc);
210 
211  dev_info(dev, "rtc core: registered %s as %s\n",
212  rtc->name, dev_name(&rtc->dev));
213 
214  return rtc;
215 
216 exit_kfree:
217  kfree(rtc);
218 
219 exit_ida:
220  ida_simple_remove(&rtc_ida, id);
221 
222 exit:
223  dev_err(dev, "rtc core: unable to register %s, err = %d\n",
224  name, err);
225  return ERR_PTR(err);
226 }
228 
229 
236 {
237  if (get_device(&rtc->dev) != NULL) {
238  mutex_lock(&rtc->ops_lock);
239  /* remove innards of this RTC, then disable it, before
240  * letting any rtc_class_open() users access it again
241  */
243  rtc_dev_del_device(rtc);
244  rtc_proc_del_device(rtc);
245  device_unregister(&rtc->dev);
246  rtc->ops = NULL;
247  ida_simple_remove(&rtc_ida, rtc->id);
248  mutex_unlock(&rtc->ops_lock);
249  put_device(&rtc->dev);
250  }
251 }
253 
254 static int __init rtc_init(void)
255 {
256  rtc_class = class_create(THIS_MODULE, "rtc");
257  if (IS_ERR(rtc_class)) {
258  printk(KERN_ERR "%s: couldn't create class\n", __FILE__);
259  return PTR_ERR(rtc_class);
260  }
261  rtc_class->suspend = rtc_suspend;
262  rtc_class->resume = rtc_resume;
263  rtc_dev_init();
264  rtc_sysfs_init(rtc_class);
265  return 0;
266 }
267 
268 static void __exit rtc_exit(void)
269 {
270  rtc_dev_exit();
271  class_destroy(rtc_class);
272  ida_destroy(&rtc_ida);
273 }
274 
275 subsys_initcall(rtc_init);
276 module_exit(rtc_exit);
277 
278 MODULE_AUTHOR("Alessandro Zummo <[email protected]>");
279 MODULE_DESCRIPTION("RTC class support");
280 MODULE_LICENSE("GPL");