summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorDavid Brownell <david-b@pacbell.net>2007-02-12 00:52:47 -0800
committerLinus Torvalds <torvalds@woody.linux-foundation.org>2007-02-12 09:48:31 -0800
commit3925a5ce44330767f7f0de5c58c6a797009f0f75 (patch)
tree67ccd2220047161031596c2e6a4f8ff3171745f7
parent802245611adea5e5877d8c5d9a20f94d8131bfdd (diff)
[PATCH] RTC gets sysfs wakealarm attribute
This adds a new "wakealarm" sysfs attribute to RTC class devices which support alarm operations and are wakeup-capable: - It reads as either empty, or the scheduled alarm time as seconds since the POSIX epoch. (That time may already have passed, since nothing currently enforces one-shot alarm semantics.) - It can be written with an alarm time in the future, again seconds since the POSIX epoch, which enables the alarm. - It can be written with an alarm time not in the future (such as 0, the start of the POSIX epoch) to disable the alarm. Usage examples (some need GNU date) after "cd /sys/class/rtc/rtcN": alarm after 10 minutes: # echo $(( $(cat since_epoch) + 10 * 60 )) > wakealarm alarm tuesday evening 10pm: # date -d '10pm tuesday' "+%s" > wakealarm disable alarm: # echo 0 > wakealarm This resembles the /proc/acpi/alarm file in that nothing happens when the alarm triggers ... except possibly waking the system from sleep. It's also like that in a nasty way: not much can be done to prevent one task from clobbering another task's alarm settings. It differs from that file in that there's no in-kernel date parser. Note that a few RTCs ignore rtc_wkalrm.enabled when setting alarms, or aren't set up correctly, so they won't yet behave with this attribute. Signed-off-by: David Brownell <dbrownell@users.sourceforge.net> Acked-by: Pavel Machek <pavel@ucw.cz> Cc: Alessandro Zummo <a.zummo@towertech.it> Cc: Greg KH <greg@kroah.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
-rw-r--r--drivers/rtc/rtc-sysfs.c103
1 files changed, 101 insertions, 2 deletions
diff --git a/drivers/rtc/rtc-sysfs.c b/drivers/rtc/rtc-sysfs.c
index 2ddd0cf07140..899ab8c514fa 100644
--- a/drivers/rtc/rtc-sysfs.c
+++ b/drivers/rtc/rtc-sysfs.c
@@ -78,6 +78,92 @@ static struct attribute_group rtc_attr_group = {
.attrs = rtc_attrs,
};
+
+static ssize_t
+rtc_sysfs_show_wakealarm(struct class_device *dev, char *buf)
+{
+ ssize_t retval;
+ unsigned long alarm;
+ struct rtc_wkalrm alm;
+
+ /* Don't show disabled alarms; but the RTC could leave the
+ * alarm enabled after it's already triggered. Alarms are
+ * conceptually one-shot, even though some common hardware
+ * (PCs) doesn't actually work that way.
+ *
+ * REVISIT maybe we should require RTC implementations to
+ * disable the RTC alarm after it triggers, for uniformity.
+ */
+ retval = rtc_read_alarm(dev, &alm);
+ if (retval == 0 && alm.enabled) {
+ rtc_tm_to_time(&alm.time, &alarm);
+ retval = sprintf(buf, "%lu\n", alarm);
+ }
+
+ return retval;
+}
+
+static ssize_t
+rtc_sysfs_set_wakealarm(struct class_device *dev, const char *buf, size_t n)
+{
+ ssize_t retval;
+ unsigned long now, alarm;
+ struct rtc_wkalrm alm;
+
+ /* Only request alarms that trigger in the future. Disable them
+ * by writing another time, e.g. 0 meaning Jan 1 1970 UTC.
+ */
+ retval = rtc_read_time(dev, &alm.time);
+ if (retval < 0)
+ return retval;
+ rtc_tm_to_time(&alm.time, &now);
+
+ alarm = simple_strtoul(buf, NULL, 0);
+ if (alarm > now) {
+ /* Avoid accidentally clobbering active alarms; we can't
+ * entirely prevent that here, without even the minimal
+ * locking from the /dev/rtcN api.
+ */
+ retval = rtc_read_alarm(dev, &alm);
+ if (retval < 0)
+ return retval;
+ if (alm.enabled)
+ return -EBUSY;
+
+ alm.enabled = 1;
+ } else {
+ alm.enabled = 0;
+
+ /* Provide a valid future alarm time. Linux isn't EFI,
+ * this time won't be ignored when disabling the alarm.
+ */
+ alarm = now + 300;
+ }
+ rtc_time_to_tm(alarm, &alm.time);
+
+ retval = rtc_set_alarm(dev, &alm);
+ return (retval < 0) ? retval : n;
+}
+static const CLASS_DEVICE_ATTR(wakealarm, S_IRUGO | S_IWUSR,
+ rtc_sysfs_show_wakealarm, rtc_sysfs_set_wakealarm);
+
+
+/* The reason to trigger an alarm with no process watching it (via sysfs)
+ * is its side effect: waking from a system state like suspend-to-RAM or
+ * suspend-to-disk. So: no attribute unless that side effect is possible.
+ * (Userspace may disable that mechanism later.)
+ */
+static inline int rtc_does_wakealarm(struct class_device *class_dev)
+{
+ struct rtc_device *rtc;
+
+ if (!device_can_wakeup(class_dev->dev))
+ return 0;
+ rtc = to_rtc_device(class_dev);
+ return rtc->ops->set_alarm != NULL;
+}
+
+
static int rtc_sysfs_add_device(struct class_device *class_dev,
struct class_interface *class_intf)
{
@@ -87,8 +173,18 @@ static int rtc_sysfs_add_device(struct class_device *class_dev,
err = sysfs_create_group(&class_dev->kobj, &rtc_attr_group);
if (err)
- dev_err(class_dev->dev,
- "failed to create sysfs attributes\n");
+ dev_err(class_dev->dev, "failed to create %s\n",
+ "sysfs attributes");
+ else if (rtc_does_wakealarm(class_dev)) {
+ /* not all RTCs support both alarms and wakeup */
+ err = class_device_create_file(class_dev,
+ &class_device_attr_wakealarm);
+ if (err) {
+ dev_err(class_dev->dev, "failed to create %s\n",
+ "alarm attribute");
+ sysfs_remove_group(&class_dev->kobj, &rtc_attr_group);
+ }
+ }
return err;
}
@@ -96,6 +192,9 @@ static int rtc_sysfs_add_device(struct class_device *class_dev,
static void rtc_sysfs_remove_device(struct class_device *class_dev,
struct class_interface *class_intf)
{
+ if (rtc_does_wakealarm(class_dev))
+ class_device_remove_file(class_dev,
+ &class_device_attr_wakealarm);
sysfs_remove_group(&class_dev->kobj, &rtc_attr_group);
}