2006-03-27 02:16:37 -07:00
|
|
|
/*
|
|
|
|
* RTC subsystem, interface functions
|
|
|
|
*
|
|
|
|
* Copyright (C) 2005 Tower Technologies
|
|
|
|
* Author: Alessandro Zummo <a.zummo@towertech.it>
|
|
|
|
*
|
|
|
|
* based on arch/arm/common/rtctime.c
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/rtc.h>
|
2007-10-16 02:28:16 -06:00
|
|
|
#include <linux/log2.h>
|
2006-03-27 02:16:37 -07:00
|
|
|
|
2007-05-08 01:33:30 -06:00
|
|
|
int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
|
2006-03-27 02:16:37 -07:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = mutex_lock_interruptible(&rtc->ops_lock);
|
|
|
|
if (err)
|
2008-07-29 23:33:30 -06:00
|
|
|
return err;
|
2006-03-27 02:16:37 -07:00
|
|
|
|
|
|
|
if (!rtc->ops)
|
|
|
|
err = -ENODEV;
|
|
|
|
else if (!rtc->ops->read_time)
|
|
|
|
err = -EINVAL;
|
|
|
|
else {
|
|
|
|
memset(tm, 0, sizeof(struct rtc_time));
|
2007-05-08 01:33:40 -06:00
|
|
|
err = rtc->ops->read_time(rtc->dev.parent, tm);
|
2006-03-27 02:16:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&rtc->ops_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtc_read_time);
|
|
|
|
|
2007-05-08 01:33:30 -06:00
|
|
|
int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
|
2006-03-27 02:16:37 -07:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = rtc_valid_tm(tm);
|
|
|
|
if (err != 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = mutex_lock_interruptible(&rtc->ops_lock);
|
|
|
|
if (err)
|
2008-07-29 23:33:30 -06:00
|
|
|
return err;
|
2006-03-27 02:16:37 -07:00
|
|
|
|
|
|
|
if (!rtc->ops)
|
|
|
|
err = -ENODEV;
|
|
|
|
else if (!rtc->ops->set_time)
|
|
|
|
err = -EINVAL;
|
|
|
|
else
|
2007-05-08 01:33:40 -06:00
|
|
|
err = rtc->ops->set_time(rtc->dev.parent, tm);
|
2006-03-27 02:16:37 -07:00
|
|
|
|
|
|
|
mutex_unlock(&rtc->ops_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtc_set_time);
|
|
|
|
|
2007-05-08 01:33:30 -06:00
|
|
|
int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
|
2006-03-27 02:16:37 -07:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = mutex_lock_interruptible(&rtc->ops_lock);
|
|
|
|
if (err)
|
2008-07-29 23:33:30 -06:00
|
|
|
return err;
|
2006-03-27 02:16:37 -07:00
|
|
|
|
|
|
|
if (!rtc->ops)
|
|
|
|
err = -ENODEV;
|
|
|
|
else if (rtc->ops->set_mmss)
|
2007-05-08 01:33:40 -06:00
|
|
|
err = rtc->ops->set_mmss(rtc->dev.parent, secs);
|
2006-03-27 02:16:37 -07:00
|
|
|
else if (rtc->ops->read_time && rtc->ops->set_time) {
|
|
|
|
struct rtc_time new, old;
|
|
|
|
|
2007-05-08 01:33:40 -06:00
|
|
|
err = rtc->ops->read_time(rtc->dev.parent, &old);
|
2006-03-27 02:16:37 -07:00
|
|
|
if (err == 0) {
|
|
|
|
rtc_time_to_tm(secs, &new);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* avoid writing when we're going to change the day of
|
|
|
|
* the month. We will retry in the next minute. This
|
|
|
|
* basically means that if the RTC must not drift
|
|
|
|
* by more than 1 minute in 11 minutes.
|
|
|
|
*/
|
|
|
|
if (!((old.tm_hour == 23 && old.tm_min == 59) ||
|
|
|
|
(new.tm_hour == 23 && new.tm_min == 59)))
|
2007-05-08 01:33:40 -06:00
|
|
|
err = rtc->ops->set_time(rtc->dev.parent,
|
2007-05-08 01:33:30 -06:00
|
|
|
&new);
|
2006-03-27 02:16:37 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
err = -EINVAL;
|
|
|
|
|
|
|
|
mutex_unlock(&rtc->ops_lock);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtc_set_mmss);
|
|
|
|
|
rtc: fix readback from /sys/class/rtc/rtc?/wakealarm
Fix readback of RTC alarms on platforms which return -1 in
non-hardware-supported RTC alarm fields.
To fill in the missing (-1) values, we grab an RTC timestamp along with the
RTC alarm value, and use the timestamp fields to populate the missing alarm
fields.
To counter field-wrap races (since the timestamp and alarm are not read
together atomically), we read the RTC timestamp both before and after
reading the RTC alarm value, and then check for wrapped fields --> if any
have wrapped, we know we have a possible inconsistency, so we loop and
reread the timestamp and alarm again.
Wrapped fields in the RTC timestamps are an issue because rtc-cmos.c, for
example, also gets/uses an RTC timestamp internally while fetching the RTC
alarm. If our timestamp here wasn't the same (minutes and higher) as what
was used internally there, then we might end up populating the -1 fields
with inconsistent values.
This fixes readbacks from /sys/class/rtc/rtc?/wakealarm, as well as other
code paths which call rtc_read_alarm().
Signed-off-by: Mark Lord <mlord@pobox.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 02:28:21 -06:00
|
|
|
static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
|
2006-03-27 02:16:37 -07:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = mutex_lock_interruptible(&rtc->ops_lock);
|
|
|
|
if (err)
|
2008-07-29 23:33:30 -06:00
|
|
|
return err;
|
2006-03-27 02:16:37 -07:00
|
|
|
|
|
|
|
if (rtc->ops == NULL)
|
|
|
|
err = -ENODEV;
|
|
|
|
else if (!rtc->ops->read_alarm)
|
|
|
|
err = -EINVAL;
|
|
|
|
else {
|
|
|
|
memset(alarm, 0, sizeof(struct rtc_wkalrm));
|
2007-05-08 01:33:40 -06:00
|
|
|
err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
|
2006-03-27 02:16:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&rtc->ops_lock);
|
|
|
|
return err;
|
|
|
|
}
|
rtc: fix readback from /sys/class/rtc/rtc?/wakealarm
Fix readback of RTC alarms on platforms which return -1 in
non-hardware-supported RTC alarm fields.
To fill in the missing (-1) values, we grab an RTC timestamp along with the
RTC alarm value, and use the timestamp fields to populate the missing alarm
fields.
To counter field-wrap races (since the timestamp and alarm are not read
together atomically), we read the RTC timestamp both before and after
reading the RTC alarm value, and then check for wrapped fields --> if any
have wrapped, we know we have a possible inconsistency, so we loop and
reread the timestamp and alarm again.
Wrapped fields in the RTC timestamps are an issue because rtc-cmos.c, for
example, also gets/uses an RTC timestamp internally while fetching the RTC
alarm. If our timestamp here wasn't the same (minutes and higher) as what
was used internally there, then we might end up populating the -1 fields
with inconsistent values.
This fixes readbacks from /sys/class/rtc/rtc?/wakealarm, as well as other
code paths which call rtc_read_alarm().
Signed-off-by: Mark Lord <mlord@pobox.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 02:28:21 -06:00
|
|
|
|
|
|
|
int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct rtc_time before, now;
|
|
|
|
int first_time = 1;
|
2008-07-04 10:59:26 -06:00
|
|
|
unsigned long t_now, t_alm;
|
|
|
|
enum { none, day, month, year } missing = none;
|
|
|
|
unsigned days;
|
rtc: fix readback from /sys/class/rtc/rtc?/wakealarm
Fix readback of RTC alarms on platforms which return -1 in
non-hardware-supported RTC alarm fields.
To fill in the missing (-1) values, we grab an RTC timestamp along with the
RTC alarm value, and use the timestamp fields to populate the missing alarm
fields.
To counter field-wrap races (since the timestamp and alarm are not read
together atomically), we read the RTC timestamp both before and after
reading the RTC alarm value, and then check for wrapped fields --> if any
have wrapped, we know we have a possible inconsistency, so we loop and
reread the timestamp and alarm again.
Wrapped fields in the RTC timestamps are an issue because rtc-cmos.c, for
example, also gets/uses an RTC timestamp internally while fetching the RTC
alarm. If our timestamp here wasn't the same (minutes and higher) as what
was used internally there, then we might end up populating the -1 fields
with inconsistent values.
This fixes readbacks from /sys/class/rtc/rtc?/wakealarm, as well as other
code paths which call rtc_read_alarm().
Signed-off-by: Mark Lord <mlord@pobox.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 02:28:21 -06:00
|
|
|
|
2008-07-04 10:59:26 -06:00
|
|
|
/* The lower level RTC driver may return -1 in some fields,
|
|
|
|
* creating invalid alarm->time values, for reasons like:
|
|
|
|
*
|
|
|
|
* - The hardware may not be capable of filling them in;
|
|
|
|
* many alarms match only on time-of-day fields, not
|
|
|
|
* day/month/year calendar data.
|
|
|
|
*
|
|
|
|
* - Some hardware uses illegal values as "wildcard" match
|
|
|
|
* values, which non-Linux firmware (like a BIOS) may try
|
|
|
|
* to set up as e.g. "alarm 15 minutes after each hour".
|
|
|
|
* Linux uses only oneshot alarms.
|
|
|
|
*
|
|
|
|
* When we see that here, we deal with it by using values from
|
|
|
|
* a current RTC timestamp for any missing (-1) values. The
|
|
|
|
* RTC driver prevents "periodic alarm" modes.
|
rtc: fix readback from /sys/class/rtc/rtc?/wakealarm
Fix readback of RTC alarms on platforms which return -1 in
non-hardware-supported RTC alarm fields.
To fill in the missing (-1) values, we grab an RTC timestamp along with the
RTC alarm value, and use the timestamp fields to populate the missing alarm
fields.
To counter field-wrap races (since the timestamp and alarm are not read
together atomically), we read the RTC timestamp both before and after
reading the RTC alarm value, and then check for wrapped fields --> if any
have wrapped, we know we have a possible inconsistency, so we loop and
reread the timestamp and alarm again.
Wrapped fields in the RTC timestamps are an issue because rtc-cmos.c, for
example, also gets/uses an RTC timestamp internally while fetching the RTC
alarm. If our timestamp here wasn't the same (minutes and higher) as what
was used internally there, then we might end up populating the -1 fields
with inconsistent values.
This fixes readbacks from /sys/class/rtc/rtc?/wakealarm, as well as other
code paths which call rtc_read_alarm().
Signed-off-by: Mark Lord <mlord@pobox.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 02:28:21 -06:00
|
|
|
*
|
|
|
|
* But this can be racey, because some fields of the RTC timestamp
|
|
|
|
* may have wrapped in the interval since we read the RTC alarm,
|
|
|
|
* which would lead to us inserting inconsistent values in place
|
|
|
|
* of the -1 fields.
|
|
|
|
*
|
|
|
|
* Reading the alarm and timestamp in the reverse sequence
|
|
|
|
* would have the same race condition, and not solve the issue.
|
|
|
|
*
|
|
|
|
* So, we must first read the RTC timestamp,
|
|
|
|
* then read the RTC alarm value,
|
|
|
|
* and then read a second RTC timestamp.
|
|
|
|
*
|
|
|
|
* If any fields of the second timestamp have changed
|
|
|
|
* when compared with the first timestamp, then we know
|
|
|
|
* our timestamp may be inconsistent with that used by
|
|
|
|
* the low-level rtc_read_alarm_internal() function.
|
|
|
|
*
|
|
|
|
* So, when the two timestamps disagree, we just loop and do
|
|
|
|
* the process again to get a fully consistent set of values.
|
|
|
|
*
|
|
|
|
* This could all instead be done in the lower level driver,
|
|
|
|
* but since more than one lower level RTC implementation needs it,
|
|
|
|
* then it's probably best best to do it here instead of there..
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Get the "before" timestamp */
|
|
|
|
err = rtc_read_time(rtc, &before);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
do {
|
|
|
|
if (!first_time)
|
|
|
|
memcpy(&before, &now, sizeof(struct rtc_time));
|
|
|
|
first_time = 0;
|
|
|
|
|
|
|
|
/* get the RTC alarm values, which may be incomplete */
|
|
|
|
err = rtc_read_alarm_internal(rtc, alarm);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
if (!alarm->enabled)
|
|
|
|
return 0;
|
|
|
|
|
2008-07-04 10:59:26 -06:00
|
|
|
/* full-function RTCs won't have such missing fields */
|
|
|
|
if (rtc_valid_tm(&alarm->time) == 0)
|
|
|
|
return 0;
|
|
|
|
|
rtc: fix readback from /sys/class/rtc/rtc?/wakealarm
Fix readback of RTC alarms on platforms which return -1 in
non-hardware-supported RTC alarm fields.
To fill in the missing (-1) values, we grab an RTC timestamp along with the
RTC alarm value, and use the timestamp fields to populate the missing alarm
fields.
To counter field-wrap races (since the timestamp and alarm are not read
together atomically), we read the RTC timestamp both before and after
reading the RTC alarm value, and then check for wrapped fields --> if any
have wrapped, we know we have a possible inconsistency, so we loop and
reread the timestamp and alarm again.
Wrapped fields in the RTC timestamps are an issue because rtc-cmos.c, for
example, also gets/uses an RTC timestamp internally while fetching the RTC
alarm. If our timestamp here wasn't the same (minutes and higher) as what
was used internally there, then we might end up populating the -1 fields
with inconsistent values.
This fixes readbacks from /sys/class/rtc/rtc?/wakealarm, as well as other
code paths which call rtc_read_alarm().
Signed-off-by: Mark Lord <mlord@pobox.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 02:28:21 -06:00
|
|
|
/* get the "after" timestamp, to detect wrapped fields */
|
|
|
|
err = rtc_read_time(rtc, &now);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* note that tm_sec is a "don't care" value here: */
|
|
|
|
} while ( before.tm_min != now.tm_min
|
|
|
|
|| before.tm_hour != now.tm_hour
|
|
|
|
|| before.tm_mon != now.tm_mon
|
2008-07-04 10:59:26 -06:00
|
|
|
|| before.tm_year != now.tm_year);
|
rtc: fix readback from /sys/class/rtc/rtc?/wakealarm
Fix readback of RTC alarms on platforms which return -1 in
non-hardware-supported RTC alarm fields.
To fill in the missing (-1) values, we grab an RTC timestamp along with the
RTC alarm value, and use the timestamp fields to populate the missing alarm
fields.
To counter field-wrap races (since the timestamp and alarm are not read
together atomically), we read the RTC timestamp both before and after
reading the RTC alarm value, and then check for wrapped fields --> if any
have wrapped, we know we have a possible inconsistency, so we loop and
reread the timestamp and alarm again.
Wrapped fields in the RTC timestamps are an issue because rtc-cmos.c, for
example, also gets/uses an RTC timestamp internally while fetching the RTC
alarm. If our timestamp here wasn't the same (minutes and higher) as what
was used internally there, then we might end up populating the -1 fields
with inconsistent values.
This fixes readbacks from /sys/class/rtc/rtc?/wakealarm, as well as other
code paths which call rtc_read_alarm().
Signed-off-by: Mark Lord <mlord@pobox.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 02:28:21 -06:00
|
|
|
|
2008-07-04 10:59:26 -06:00
|
|
|
/* Fill in the missing alarm fields using the timestamp; we
|
|
|
|
* know there's at least one since alarm->time is invalid.
|
|
|
|
*/
|
rtc: fix readback from /sys/class/rtc/rtc?/wakealarm
Fix readback of RTC alarms on platforms which return -1 in
non-hardware-supported RTC alarm fields.
To fill in the missing (-1) values, we grab an RTC timestamp along with the
RTC alarm value, and use the timestamp fields to populate the missing alarm
fields.
To counter field-wrap races (since the timestamp and alarm are not read
together atomically), we read the RTC timestamp both before and after
reading the RTC alarm value, and then check for wrapped fields --> if any
have wrapped, we know we have a possible inconsistency, so we loop and
reread the timestamp and alarm again.
Wrapped fields in the RTC timestamps are an issue because rtc-cmos.c, for
example, also gets/uses an RTC timestamp internally while fetching the RTC
alarm. If our timestamp here wasn't the same (minutes and higher) as what
was used internally there, then we might end up populating the -1 fields
with inconsistent values.
This fixes readbacks from /sys/class/rtc/rtc?/wakealarm, as well as other
code paths which call rtc_read_alarm().
Signed-off-by: Mark Lord <mlord@pobox.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 02:28:21 -06:00
|
|
|
if (alarm->time.tm_sec == -1)
|
|
|
|
alarm->time.tm_sec = now.tm_sec;
|
|
|
|
if (alarm->time.tm_min == -1)
|
|
|
|
alarm->time.tm_min = now.tm_min;
|
|
|
|
if (alarm->time.tm_hour == -1)
|
|
|
|
alarm->time.tm_hour = now.tm_hour;
|
2008-07-04 10:59:26 -06:00
|
|
|
|
|
|
|
/* For simplicity, only support date rollover for now */
|
|
|
|
if (alarm->time.tm_mday == -1) {
|
rtc: fix readback from /sys/class/rtc/rtc?/wakealarm
Fix readback of RTC alarms on platforms which return -1 in
non-hardware-supported RTC alarm fields.
To fill in the missing (-1) values, we grab an RTC timestamp along with the
RTC alarm value, and use the timestamp fields to populate the missing alarm
fields.
To counter field-wrap races (since the timestamp and alarm are not read
together atomically), we read the RTC timestamp both before and after
reading the RTC alarm value, and then check for wrapped fields --> if any
have wrapped, we know we have a possible inconsistency, so we loop and
reread the timestamp and alarm again.
Wrapped fields in the RTC timestamps are an issue because rtc-cmos.c, for
example, also gets/uses an RTC timestamp internally while fetching the RTC
alarm. If our timestamp here wasn't the same (minutes and higher) as what
was used internally there, then we might end up populating the -1 fields
with inconsistent values.
This fixes readbacks from /sys/class/rtc/rtc?/wakealarm, as well as other
code paths which call rtc_read_alarm().
Signed-off-by: Mark Lord <mlord@pobox.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 02:28:21 -06:00
|
|
|
alarm->time.tm_mday = now.tm_mday;
|
2008-07-04 10:59:26 -06:00
|
|
|
missing = day;
|
|
|
|
}
|
|
|
|
if (alarm->time.tm_mon == -1) {
|
rtc: fix readback from /sys/class/rtc/rtc?/wakealarm
Fix readback of RTC alarms on platforms which return -1 in
non-hardware-supported RTC alarm fields.
To fill in the missing (-1) values, we grab an RTC timestamp along with the
RTC alarm value, and use the timestamp fields to populate the missing alarm
fields.
To counter field-wrap races (since the timestamp and alarm are not read
together atomically), we read the RTC timestamp both before and after
reading the RTC alarm value, and then check for wrapped fields --> if any
have wrapped, we know we have a possible inconsistency, so we loop and
reread the timestamp and alarm again.
Wrapped fields in the RTC timestamps are an issue because rtc-cmos.c, for
example, also gets/uses an RTC timestamp internally while fetching the RTC
alarm. If our timestamp here wasn't the same (minutes and higher) as what
was used internally there, then we might end up populating the -1 fields
with inconsistent values.
This fixes readbacks from /sys/class/rtc/rtc?/wakealarm, as well as other
code paths which call rtc_read_alarm().
Signed-off-by: Mark Lord <mlord@pobox.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 02:28:21 -06:00
|
|
|
alarm->time.tm_mon = now.tm_mon;
|
2008-07-04 10:59:26 -06:00
|
|
|
if (missing == none)
|
|
|
|
missing = month;
|
|
|
|
}
|
|
|
|
if (alarm->time.tm_year == -1) {
|
rtc: fix readback from /sys/class/rtc/rtc?/wakealarm
Fix readback of RTC alarms on platforms which return -1 in
non-hardware-supported RTC alarm fields.
To fill in the missing (-1) values, we grab an RTC timestamp along with the
RTC alarm value, and use the timestamp fields to populate the missing alarm
fields.
To counter field-wrap races (since the timestamp and alarm are not read
together atomically), we read the RTC timestamp both before and after
reading the RTC alarm value, and then check for wrapped fields --> if any
have wrapped, we know we have a possible inconsistency, so we loop and
reread the timestamp and alarm again.
Wrapped fields in the RTC timestamps are an issue because rtc-cmos.c, for
example, also gets/uses an RTC timestamp internally while fetching the RTC
alarm. If our timestamp here wasn't the same (minutes and higher) as what
was used internally there, then we might end up populating the -1 fields
with inconsistent values.
This fixes readbacks from /sys/class/rtc/rtc?/wakealarm, as well as other
code paths which call rtc_read_alarm().
Signed-off-by: Mark Lord <mlord@pobox.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 02:28:21 -06:00
|
|
|
alarm->time.tm_year = now.tm_year;
|
2008-07-04 10:59:26 -06:00
|
|
|
if (missing == none)
|
|
|
|
missing = year;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* with luck, no rollover is needed */
|
|
|
|
rtc_tm_to_time(&now, &t_now);
|
|
|
|
rtc_tm_to_time(&alarm->time, &t_alm);
|
|
|
|
if (t_now < t_alm)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
switch (missing) {
|
|
|
|
|
|
|
|
/* 24 hour rollover ... if it's now 10am Monday, an alarm that
|
|
|
|
* that will trigger at 5am will do so at 5am Tuesday, which
|
|
|
|
* could also be in the next month or year. This is a common
|
|
|
|
* case, especially for PCs.
|
|
|
|
*/
|
|
|
|
case day:
|
|
|
|
dev_dbg(&rtc->dev, "alarm rollover: %s\n", "day");
|
|
|
|
t_alm += 24 * 60 * 60;
|
|
|
|
rtc_time_to_tm(t_alm, &alarm->time);
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Month rollover ... if it's the 31th, an alarm on the 3rd will
|
|
|
|
* be next month. An alarm matching on the 30th, 29th, or 28th
|
|
|
|
* may end up in the month after that! Many newer PCs support
|
|
|
|
* this type of alarm.
|
|
|
|
*/
|
|
|
|
case month:
|
|
|
|
dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month");
|
|
|
|
do {
|
|
|
|
if (alarm->time.tm_mon < 11)
|
|
|
|
alarm->time.tm_mon++;
|
|
|
|
else {
|
|
|
|
alarm->time.tm_mon = 0;
|
|
|
|
alarm->time.tm_year++;
|
|
|
|
}
|
|
|
|
days = rtc_month_days(alarm->time.tm_mon,
|
|
|
|
alarm->time.tm_year);
|
|
|
|
} while (days < alarm->time.tm_mday);
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Year rollover ... easy except for leap years! */
|
|
|
|
case year:
|
|
|
|
dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year");
|
|
|
|
do {
|
|
|
|
alarm->time.tm_year++;
|
2008-11-06 13:53:18 -07:00
|
|
|
} while (rtc_valid_tm(&alarm->time) != 0);
|
2008-07-04 10:59:26 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
dev_warn(&rtc->dev, "alarm rollover not handled\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
rtc: fix readback from /sys/class/rtc/rtc?/wakealarm
Fix readback of RTC alarms on platforms which return -1 in
non-hardware-supported RTC alarm fields.
To fill in the missing (-1) values, we grab an RTC timestamp along with the
RTC alarm value, and use the timestamp fields to populate the missing alarm
fields.
To counter field-wrap races (since the timestamp and alarm are not read
together atomically), we read the RTC timestamp both before and after
reading the RTC alarm value, and then check for wrapped fields --> if any
have wrapped, we know we have a possible inconsistency, so we loop and
reread the timestamp and alarm again.
Wrapped fields in the RTC timestamps are an issue because rtc-cmos.c, for
example, also gets/uses an RTC timestamp internally while fetching the RTC
alarm. If our timestamp here wasn't the same (minutes and higher) as what
was used internally there, then we might end up populating the -1 fields
with inconsistent values.
This fixes readbacks from /sys/class/rtc/rtc?/wakealarm, as well as other
code paths which call rtc_read_alarm().
Signed-off-by: Mark Lord <mlord@pobox.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 02:28:21 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2006-03-27 02:16:37 -07:00
|
|
|
EXPORT_SYMBOL_GPL(rtc_read_alarm);
|
|
|
|
|
2007-05-08 01:33:30 -06:00
|
|
|
int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
|
2006-03-27 02:16:37 -07:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2007-05-08 01:34:07 -06:00
|
|
|
err = rtc_valid_tm(&alarm->time);
|
|
|
|
if (err != 0)
|
|
|
|
return err;
|
|
|
|
|
2006-03-27 02:16:37 -07:00
|
|
|
err = mutex_lock_interruptible(&rtc->ops_lock);
|
|
|
|
if (err)
|
2008-07-29 23:33:30 -06:00
|
|
|
return err;
|
2006-03-27 02:16:37 -07:00
|
|
|
|
|
|
|
if (!rtc->ops)
|
|
|
|
err = -ENODEV;
|
|
|
|
else if (!rtc->ops->set_alarm)
|
|
|
|
err = -EINVAL;
|
|
|
|
else
|
2007-05-08 01:33:40 -06:00
|
|
|
err = rtc->ops->set_alarm(rtc->dev.parent, alarm);
|
2006-03-27 02:16:37 -07:00
|
|
|
|
|
|
|
mutex_unlock(&rtc->ops_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtc_set_alarm);
|
|
|
|
|
2009-01-04 13:00:54 -07:00
|
|
|
int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
|
|
|
|
{
|
|
|
|
int err = mutex_lock_interruptible(&rtc->ops_lock);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (!rtc->ops)
|
|
|
|
err = -ENODEV;
|
|
|
|
else if (!rtc->ops->alarm_irq_enable)
|
|
|
|
err = -EINVAL;
|
|
|
|
else
|
|
|
|
err = rtc->ops->alarm_irq_enable(rtc->dev.parent, enabled);
|
|
|
|
|
|
|
|
mutex_unlock(&rtc->ops_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable);
|
|
|
|
|
|
|
|
int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
|
|
|
|
{
|
|
|
|
int err = mutex_lock_interruptible(&rtc->ops_lock);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
|
|
|
|
if (enabled == 0 && rtc->uie_irq_active) {
|
|
|
|
mutex_unlock(&rtc->ops_lock);
|
|
|
|
return rtc_dev_update_irq_enable_emul(rtc, enabled);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!rtc->ops)
|
|
|
|
err = -ENODEV;
|
|
|
|
else if (!rtc->ops->update_irq_enable)
|
|
|
|
err = -EINVAL;
|
|
|
|
else
|
|
|
|
err = rtc->ops->update_irq_enable(rtc->dev.parent, enabled);
|
|
|
|
|
|
|
|
mutex_unlock(&rtc->ops_lock);
|
|
|
|
|
|
|
|
#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
|
|
|
|
/*
|
|
|
|
* Enable emulation if the driver did not provide
|
|
|
|
* the update_irq_enable function pointer or if returned
|
|
|
|
* -EINVAL to signal that it has been configured without
|
|
|
|
* interrupts or that are not available at the moment.
|
|
|
|
*/
|
|
|
|
if (err == -EINVAL)
|
|
|
|
err = rtc_dev_update_irq_enable_emul(rtc, enabled);
|
|
|
|
#endif
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtc_update_irq_enable);
|
|
|
|
|
2006-11-25 12:09:28 -07:00
|
|
|
/**
|
|
|
|
* rtc_update_irq - report RTC periodic, alarm, and/or update irqs
|
2007-05-08 01:33:30 -06:00
|
|
|
* @rtc: the rtc device
|
2006-11-25 12:09:28 -07:00
|
|
|
* @num: how many irqs are being reported (usually one)
|
|
|
|
* @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
|
|
|
|
* Context: in_interrupt(), irqs blocked
|
|
|
|
*/
|
2007-05-08 01:33:30 -06:00
|
|
|
void rtc_update_irq(struct rtc_device *rtc,
|
2006-03-27 02:16:37 -07:00
|
|
|
unsigned long num, unsigned long events)
|
|
|
|
{
|
|
|
|
spin_lock(&rtc->irq_lock);
|
|
|
|
rtc->irq_data = (rtc->irq_data + (num << 8)) | events;
|
|
|
|
spin_unlock(&rtc->irq_lock);
|
|
|
|
|
|
|
|
spin_lock(&rtc->irq_task_lock);
|
|
|
|
if (rtc->irq_task)
|
|
|
|
rtc->irq_task->func(rtc->irq_task->private_data);
|
|
|
|
spin_unlock(&rtc->irq_task_lock);
|
|
|
|
|
|
|
|
wake_up_interruptible(&rtc->irq_queue);
|
|
|
|
kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtc_update_irq);
|
|
|
|
|
2008-01-21 23:00:34 -07:00
|
|
|
static int __rtc_match(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
char *name = (char *)data;
|
|
|
|
|
|
|
|
if (strncmp(dev->bus_id, name, BUS_ID_SIZE) == 0)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-05-08 01:33:30 -06:00
|
|
|
struct rtc_device *rtc_class_open(char *name)
|
2006-03-27 02:16:37 -07:00
|
|
|
{
|
2007-05-08 01:33:40 -06:00
|
|
|
struct device *dev;
|
2007-05-08 01:33:30 -06:00
|
|
|
struct rtc_device *rtc = NULL;
|
2006-03-27 02:16:37 -07:00
|
|
|
|
2008-05-22 15:21:08 -06:00
|
|
|
dev = class_find_device(rtc_class, NULL, name, __rtc_match);
|
2008-01-21 23:00:34 -07:00
|
|
|
if (dev)
|
|
|
|
rtc = to_rtc_device(dev);
|
2006-03-27 02:16:37 -07:00
|
|
|
|
2007-05-08 01:33:30 -06:00
|
|
|
if (rtc) {
|
|
|
|
if (!try_module_get(rtc->owner)) {
|
2007-05-08 01:33:40 -06:00
|
|
|
put_device(dev);
|
2007-05-08 01:33:30 -06:00
|
|
|
rtc = NULL;
|
|
|
|
}
|
2006-03-27 02:16:37 -07:00
|
|
|
}
|
|
|
|
|
2007-05-08 01:33:30 -06:00
|
|
|
return rtc;
|
2006-03-27 02:16:37 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtc_class_open);
|
|
|
|
|
2007-05-08 01:33:30 -06:00
|
|
|
void rtc_class_close(struct rtc_device *rtc)
|
2006-03-27 02:16:37 -07:00
|
|
|
{
|
2007-05-08 01:33:30 -06:00
|
|
|
module_put(rtc->owner);
|
2007-05-08 01:33:40 -06:00
|
|
|
put_device(&rtc->dev);
|
2006-03-27 02:16:37 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtc_class_close);
|
|
|
|
|
2007-05-08 01:33:30 -06:00
|
|
|
int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task)
|
2006-03-27 02:16:37 -07:00
|
|
|
{
|
|
|
|
int retval = -EBUSY;
|
|
|
|
|
|
|
|
if (task == NULL || task->func == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2007-10-16 02:28:15 -06:00
|
|
|
/* Cannot register while the char dev is in use */
|
2007-12-05 00:45:05 -07:00
|
|
|
if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
|
2007-10-16 02:28:15 -06:00
|
|
|
return -EBUSY;
|
|
|
|
|
2006-11-25 12:09:28 -07:00
|
|
|
spin_lock_irq(&rtc->irq_task_lock);
|
2006-03-27 02:16:37 -07:00
|
|
|
if (rtc->irq_task == NULL) {
|
|
|
|
rtc->irq_task = task;
|
|
|
|
retval = 0;
|
|
|
|
}
|
2006-11-25 12:09:28 -07:00
|
|
|
spin_unlock_irq(&rtc->irq_task_lock);
|
2006-03-27 02:16:37 -07:00
|
|
|
|
2007-12-05 00:45:05 -07:00
|
|
|
clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
|
2007-10-16 02:28:15 -06:00
|
|
|
|
2006-03-27 02:16:37 -07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtc_irq_register);
|
|
|
|
|
2007-05-08 01:33:30 -06:00
|
|
|
void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task)
|
2006-03-27 02:16:37 -07:00
|
|
|
{
|
2006-11-25 12:09:28 -07:00
|
|
|
spin_lock_irq(&rtc->irq_task_lock);
|
2006-03-27 02:16:37 -07:00
|
|
|
if (rtc->irq_task == task)
|
|
|
|
rtc->irq_task = NULL;
|
2006-11-25 12:09:28 -07:00
|
|
|
spin_unlock_irq(&rtc->irq_task_lock);
|
2006-03-27 02:16:37 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtc_irq_unregister);
|
|
|
|
|
2007-10-16 02:28:16 -06:00
|
|
|
/**
|
|
|
|
* rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs
|
|
|
|
* @rtc: the rtc device
|
|
|
|
* @task: currently registered with rtc_irq_register()
|
|
|
|
* @enabled: true to enable periodic IRQs
|
|
|
|
* Context: any
|
|
|
|
*
|
|
|
|
* Note that rtc_irq_set_freq() should previously have been used to
|
|
|
|
* specify the desired frequency of periodic IRQ task->func() callbacks.
|
|
|
|
*/
|
2007-05-08 01:33:30 -06:00
|
|
|
int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
|
2006-03-27 02:16:37 -07:00
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2006-06-25 06:48:20 -06:00
|
|
|
if (rtc->ops->irq_set_state == NULL)
|
|
|
|
return -ENXIO;
|
|
|
|
|
2006-03-27 02:16:37 -07:00
|
|
|
spin_lock_irqsave(&rtc->irq_task_lock, flags);
|
2007-10-16 02:28:15 -06:00
|
|
|
if (rtc->irq_task != NULL && task == NULL)
|
|
|
|
err = -EBUSY;
|
2006-03-27 02:16:37 -07:00
|
|
|
if (rtc->irq_task != task)
|
2007-10-16 02:28:15 -06:00
|
|
|
err = -EACCES;
|
2006-03-27 02:16:37 -07:00
|
|
|
spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
|
|
|
|
|
|
|
|
if (err == 0)
|
2007-05-08 01:33:40 -06:00
|
|
|
err = rtc->ops->irq_set_state(rtc->dev.parent, enabled);
|
2006-03-27 02:16:37 -07:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtc_irq_set_state);
|
|
|
|
|
2007-10-16 02:28:16 -06:00
|
|
|
/**
|
|
|
|
* rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ
|
|
|
|
* @rtc: the rtc device
|
|
|
|
* @task: currently registered with rtc_irq_register()
|
|
|
|
* @freq: positive frequency with which task->func() will be called
|
|
|
|
* Context: any
|
|
|
|
*
|
|
|
|
* Note that rtc_irq_set_state() is used to enable or disable the
|
|
|
|
* periodic IRQs.
|
|
|
|
*/
|
2007-05-08 01:33:30 -06:00
|
|
|
int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
|
2006-03-27 02:16:37 -07:00
|
|
|
{
|
2006-06-25 06:48:20 -06:00
|
|
|
int err = 0;
|
2006-03-27 02:16:37 -07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2006-06-25 06:48:20 -06:00
|
|
|
if (rtc->ops->irq_set_freq == NULL)
|
|
|
|
return -ENXIO;
|
2006-03-27 02:16:37 -07:00
|
|
|
|
2007-10-16 02:28:16 -06:00
|
|
|
if (!is_power_of_2(freq))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2006-03-27 02:16:37 -07:00
|
|
|
spin_lock_irqsave(&rtc->irq_task_lock, flags);
|
2007-10-16 02:28:15 -06:00
|
|
|
if (rtc->irq_task != NULL && task == NULL)
|
|
|
|
err = -EBUSY;
|
2006-03-27 02:16:37 -07:00
|
|
|
if (rtc->irq_task != task)
|
2007-10-16 02:28:15 -06:00
|
|
|
err = -EACCES;
|
2006-03-27 02:16:37 -07:00
|
|
|
spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
|
|
|
|
|
|
|
|
if (err == 0) {
|
2007-05-08 01:33:40 -06:00
|
|
|
err = rtc->ops->irq_set_freq(rtc->dev.parent, freq);
|
2006-03-27 02:16:37 -07:00
|
|
|
if (err == 0)
|
|
|
|
rtc->irq_freq = freq;
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
2006-11-25 12:09:27 -07:00
|
|
|
EXPORT_SYMBOL_GPL(rtc_irq_set_freq);
|