rtc: simplified rtc sysfs attribute handling
[linux-2.6.git] / drivers / rtc / rtc-sysfs.c
1 /*
2  * RTC subsystem, sysfs interface
3  *
4  * Copyright (C) 2005 Tower Technologies
5  * Author: Alessandro Zummo <a.zummo@towertech.it>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10 */
11
12 #include <linux/module.h>
13 #include <linux/rtc.h>
14
15 #include "rtc-core.h"
16
17
18 /* device attributes */
19
20 static ssize_t rtc_sysfs_show_name(struct class_device *dev, char *buf)
21 {
22         return sprintf(buf, "%s\n", to_rtc_device(dev)->name);
23 }
24
25 static ssize_t rtc_sysfs_show_date(struct class_device *dev, char *buf)
26 {
27         ssize_t retval;
28         struct rtc_time tm;
29
30         retval = rtc_read_time(to_rtc_device(dev), &tm);
31         if (retval == 0) {
32                 retval = sprintf(buf, "%04d-%02d-%02d\n",
33                         tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
34         }
35
36         return retval;
37 }
38
39 static ssize_t rtc_sysfs_show_time(struct class_device *dev, char *buf)
40 {
41         ssize_t retval;
42         struct rtc_time tm;
43
44         retval = rtc_read_time(to_rtc_device(dev), &tm);
45         if (retval == 0) {
46                 retval = sprintf(buf, "%02d:%02d:%02d\n",
47                         tm.tm_hour, tm.tm_min, tm.tm_sec);
48         }
49
50         return retval;
51 }
52
53 static ssize_t rtc_sysfs_show_since_epoch(struct class_device *dev, char *buf)
54 {
55         ssize_t retval;
56         struct rtc_time tm;
57
58         retval = rtc_read_time(to_rtc_device(dev), &tm);
59         if (retval == 0) {
60                 unsigned long time;
61                 rtc_tm_to_time(&tm, &time);
62                 retval = sprintf(buf, "%lu\n", time);
63         }
64
65         return retval;
66 }
67
68 static struct class_device_attribute rtc_attrs[] = {
69         __ATTR(name, S_IRUGO, rtc_sysfs_show_name, NULL),
70         __ATTR(date, S_IRUGO, rtc_sysfs_show_date, NULL),
71         __ATTR(time, S_IRUGO, rtc_sysfs_show_time, NULL),
72         __ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL),
73         { },
74 };
75
76 static ssize_t
77 rtc_sysfs_show_wakealarm(struct class_device *dev, char *buf)
78 {
79         ssize_t retval;
80         unsigned long alarm;
81         struct rtc_wkalrm alm;
82
83         /* Don't show disabled alarms; but the RTC could leave the
84          * alarm enabled after it's already triggered.  Alarms are
85          * conceptually one-shot, even though some common hardware
86          * (PCs) doesn't actually work that way.
87          *
88          * REVISIT maybe we should require RTC implementations to
89          * disable the RTC alarm after it triggers, for uniformity.
90          */
91         retval = rtc_read_alarm(to_rtc_device(dev), &alm);
92         if (retval == 0 && alm.enabled) {
93                 rtc_tm_to_time(&alm.time, &alarm);
94                 retval = sprintf(buf, "%lu\n", alarm);
95         }
96
97         return retval;
98 }
99
100 static ssize_t
101 rtc_sysfs_set_wakealarm(struct class_device *dev, const char *buf, size_t n)
102 {
103         ssize_t retval;
104         unsigned long now, alarm;
105         struct rtc_wkalrm alm;
106         struct rtc_device *rtc = to_rtc_device(dev);
107
108         /* Only request alarms that trigger in the future.  Disable them
109          * by writing another time, e.g. 0 meaning Jan 1 1970 UTC.
110          */
111         retval = rtc_read_time(rtc, &alm.time);
112         if (retval < 0)
113                 return retval;
114         rtc_tm_to_time(&alm.time, &now);
115
116         alarm = simple_strtoul(buf, NULL, 0);
117         if (alarm > now) {
118                 /* Avoid accidentally clobbering active alarms; we can't
119                  * entirely prevent that here, without even the minimal
120                  * locking from the /dev/rtcN api.
121                  */
122                 retval = rtc_read_alarm(rtc, &alm);
123                 if (retval < 0)
124                         return retval;
125                 if (alm.enabled)
126                         return -EBUSY;
127
128                 alm.enabled = 1;
129         } else {
130                 alm.enabled = 0;
131
132                 /* Provide a valid future alarm time.  Linux isn't EFI,
133                  * this time won't be ignored when disabling the alarm.
134                  */
135                 alarm = now + 300;
136         }
137         rtc_time_to_tm(alarm, &alm.time);
138
139         retval = rtc_set_alarm(rtc, &alm);
140         return (retval < 0) ? retval : n;
141 }
142 static const CLASS_DEVICE_ATTR(wakealarm, S_IRUGO | S_IWUSR,
143                 rtc_sysfs_show_wakealarm, rtc_sysfs_set_wakealarm);
144
145
146 /* The reason to trigger an alarm with no process watching it (via sysfs)
147  * is its side effect:  waking from a system state like suspend-to-RAM or
148  * suspend-to-disk.  So: no attribute unless that side effect is possible.
149  * (Userspace may disable that mechanism later.)
150  */
151 static inline int rtc_does_wakealarm(struct rtc_device *rtc)
152 {
153         if (!device_can_wakeup(rtc->class_dev.dev))
154                 return 0;
155         return rtc->ops->set_alarm != NULL;
156 }
157
158
159 void rtc_sysfs_add_device(struct rtc_device *rtc)
160 {
161         int err;
162
163         /* not all RTCs support both alarms and wakeup */
164         if (!rtc_does_wakealarm(rtc))
165                 return;
166
167         err = class_device_create_file(&rtc->class_dev,
168                                 &class_device_attr_wakealarm);
169         if (err)
170                 dev_err(rtc->class_dev.dev, "failed to create "
171                                 "alarm attribute, %d",
172                                 err);
173 }
174
175 void rtc_sysfs_del_device(struct rtc_device *rtc)
176 {
177         /* REVISIT did we add it successfully? */
178         if (rtc_does_wakealarm(rtc))
179                 class_device_remove_file(&rtc->class_dev,
180                                 &class_device_attr_wakealarm);
181 }
182
183 void __init rtc_sysfs_init(struct class *rtc_class)
184 {
185         rtc_class->class_dev_attrs = rtc_attrs;
186 }