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/*
 21 * NOTE:  RTC times displayed in sysfs use the RTC's timezone.  That's
 22 * ideally UTC.  However, PCs that also boot to MS-Windows normally use
 23 * the local time and change to match daylight savings time.  That affects
 24 * attributes including date, time, since_epoch, and wakealarm.
 25 */
 26
 27static ssize_t
 28rtc_sysfs_show_name(struct device *dev, struct device_attribute *attr,
 29		char *buf)
 30{
 31	return sprintf(buf, "%s\n", to_rtc_device(dev)->name);
 32}
 33
 34static ssize_t
 35rtc_sysfs_show_date(struct device *dev, struct device_attribute *attr,
 36		char *buf)
 37{
 38	ssize_t retval;
 39	struct rtc_time tm;
 40
 41	retval = rtc_read_time(to_rtc_device(dev), &tm);
 42	if (retval == 0) {
 43		retval = sprintf(buf, "%04d-%02d-%02d\n",
 44			tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
 45	}
 46
 47	return retval;
 48}
 49
 50static ssize_t
 51rtc_sysfs_show_time(struct device *dev, struct device_attribute *attr,
 52		char *buf)
 53{
 54	ssize_t retval;
 55	struct rtc_time tm;
 56
 57	retval = rtc_read_time(to_rtc_device(dev), &tm);
 58	if (retval == 0) {
 59		retval = sprintf(buf, "%02d:%02d:%02d\n",
 60			tm.tm_hour, tm.tm_min, tm.tm_sec);
 61	}
 62
 63	return retval;
 64}
 65
 66static ssize_t
 67rtc_sysfs_show_since_epoch(struct device *dev, struct device_attribute *attr,
 68		char *buf)
 69{
 70	ssize_t retval;
 71	struct rtc_time tm;
 72
 73	retval = rtc_read_time(to_rtc_device(dev), &tm);
 74	if (retval == 0) {
 75		unsigned long time;
 76		rtc_tm_to_time(&tm, &time);
 77		retval = sprintf(buf, "%lu\n", time);
 78	}
 79
 80	return retval;
 81}
 82
 83static ssize_t
 84rtc_sysfs_show_max_user_freq(struct device *dev, struct device_attribute *attr,
 85		char *buf)
 86{
 87	return sprintf(buf, "%d\n", to_rtc_device(dev)->max_user_freq);
 88}
 89
 90static ssize_t
 91rtc_sysfs_set_max_user_freq(struct device *dev, struct device_attribute *attr,
 92		const char *buf, size_t n)
 93{
 94	struct rtc_device *rtc = to_rtc_device(dev);
 95	unsigned long val = simple_strtoul(buf, NULL, 0);
 96
 97	if (val >= 4096 || val == 0)
 98		return -EINVAL;
 99
100	rtc->max_user_freq = (int)val;
101
102	return n;
103}
104
105static ssize_t
106rtc_sysfs_show_hctosys(struct device *dev, struct device_attribute *attr,
107		char *buf)
108{
109#ifdef CONFIG_RTC_HCTOSYS_DEVICE
110	if (rtc_hctosys_ret == 0 &&
111			strcmp(dev_name(&to_rtc_device(dev)->dev),
112				CONFIG_RTC_HCTOSYS_DEVICE) == 0)
113		return sprintf(buf, "1\n");
114	else
115#endif
116		return sprintf(buf, "0\n");
117}
118
119static struct device_attribute rtc_attrs[] = {
120	__ATTR(name, S_IRUGO, rtc_sysfs_show_name, NULL),
121	__ATTR(date, S_IRUGO, rtc_sysfs_show_date, NULL),
122	__ATTR(time, S_IRUGO, rtc_sysfs_show_time, NULL),
123	__ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL),
124	__ATTR(max_user_freq, S_IRUGO | S_IWUSR, rtc_sysfs_show_max_user_freq,
125			rtc_sysfs_set_max_user_freq),
126	__ATTR(hctosys, S_IRUGO, rtc_sysfs_show_hctosys, NULL),
127	{ },
128};
129
130static ssize_t
131rtc_sysfs_show_wakealarm(struct device *dev, struct device_attribute *attr,
132		char *buf)
133{
134	ssize_t retval;
135	unsigned long alarm;
136	struct rtc_wkalrm alm;
137
138	/* Don't show disabled alarms.  For uniformity, RTC alarms are
139	 * conceptually one-shot, even though some common RTCs (on PCs)
140	 * don't actually work that way.
141	 *
142	 * NOTE: RTC implementations where the alarm doesn't match an
143	 * exact YYYY-MM-DD HH:MM[:SS] date *must* disable their RTC
144	 * alarms after they trigger, to ensure one-shot semantics.
145	 */
146	retval = rtc_read_alarm(to_rtc_device(dev), &alm);
147	if (retval == 0 && alm.enabled) {
148		rtc_tm_to_time(&alm.time, &alarm);
149		retval = sprintf(buf, "%lu\n", alarm);
150	}
151
152	return retval;
153}
154
155static ssize_t
156rtc_sysfs_set_wakealarm(struct device *dev, struct device_attribute *attr,
157		const char *buf, size_t n)
158{
159	ssize_t retval;
160	unsigned long now, alarm;
161	struct rtc_wkalrm alm;
162	struct rtc_device *rtc = to_rtc_device(dev);
163	char *buf_ptr;
164	int adjust = 0;
165
166	/* Only request alarms that trigger in the future.  Disable them
167	 * by writing another time, e.g. 0 meaning Jan 1 1970 UTC.
168	 */
169	retval = rtc_read_time(rtc, &alm.time);
170	if (retval < 0)
171		return retval;
172	rtc_tm_to_time(&alm.time, &now);
173
174	buf_ptr = (char *)buf;
175	if (*buf_ptr == '+') {
176		buf_ptr++;
177		adjust = 1;
178	}
179	alarm = simple_strtoul(buf_ptr, NULL, 0);
180	if (adjust) {
181		alarm += now;
182	}
183	if (alarm > now) {
184		/* Avoid accidentally clobbering active alarms; we can't
185		 * entirely prevent that here, without even the minimal
186		 * locking from the /dev/rtcN api.
187		 */
188		retval = rtc_read_alarm(rtc, &alm);
189		if (retval < 0)
190			return retval;
191		if (alm.enabled)
192			return -EBUSY;
193
194		alm.enabled = 1;
195	} else {
196		alm.enabled = 0;
197
198		/* Provide a valid future alarm time.  Linux isn't EFI,
199		 * this time won't be ignored when disabling the alarm.
200		 */
201		alarm = now + 300;
202	}
203	rtc_time_to_tm(alarm, &alm.time);
204
205	retval = rtc_set_alarm(rtc, &alm);
206	return (retval < 0) ? retval : n;
207}
208static DEVICE_ATTR(wakealarm, S_IRUGO | S_IWUSR,
209		rtc_sysfs_show_wakealarm, rtc_sysfs_set_wakealarm);
210
211
212/* The reason to trigger an alarm with no process watching it (via sysfs)
213 * is its side effect:  waking from a system state like suspend-to-RAM or
214 * suspend-to-disk.  So: no attribute unless that side effect is possible.
215 * (Userspace may disable that mechanism later.)
216 */
217static inline int rtc_does_wakealarm(struct rtc_device *rtc)
218{
219	if (!device_can_wakeup(rtc->dev.parent))
220		return 0;
221	return rtc->ops->set_alarm != NULL;
222}
223
224
225void rtc_sysfs_add_device(struct rtc_device *rtc)
226{
227	int err;
228
229	/* not all RTCs support both alarms and wakeup */
230	if (!rtc_does_wakealarm(rtc))
231		return;
232
233	err = device_create_file(&rtc->dev, &dev_attr_wakealarm);
234	if (err)
235		dev_err(rtc->dev.parent,
236			"failed to create alarm attribute, %d\n", err);
237}
238
239void rtc_sysfs_del_device(struct rtc_device *rtc)
240{
241	/* REVISIT did we add it successfully? */
242	if (rtc_does_wakealarm(rtc))
243		device_remove_file(&rtc->dev, &dev_attr_wakealarm);
244}
245
246void __init rtc_sysfs_init(struct class *rtc_class)
247{
248	rtc_class->dev_attrs = rtc_attrs;
249}