// SPDX-License-Identifier: GPL-2.0/* * RTC subsystem, interface functions * * Copyright (C) 2005 Tower Technologies * Author: Alessandro Zummo <a.zummo@towertech.it> * * based on arch/arm/common/rtctime.c */ #include <linux/rtc.h>#include <linux/sched.h>#include <linux/module.h>#include <linux/log2.h>#include <linux/workqueue.h> #define CREATE_TRACE_POINTS#include <trace/events/rtc.h> static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer);static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer); static void rtc_add_offset(struct rtc_device *rtc, struct rtc_time *tm){	time64_t secs; 	if (!rtc->offset_secs)		return; 	secs = rtc_tm_to_time64(tm); 	/*	 * Since the reading time values from RTC device are always in the RTC	 * original valid range, but we need to skip the overlapped region	 * between expanded range and original range, which is no need to add	 * the offset.	 */	if ((rtc->start_secs > rtc->range_min && secs >= rtc->start_secs) ||	    (rtc->start_secs < rtc->range_min &&	     secs <= (rtc->start_secs + rtc->range_max - rtc->range_min)))		return; 	rtc_time64_to_tm(secs + rtc->offset_secs, tm);} static void rtc_subtract_offset(struct rtc_device *rtc, struct rtc_time *tm){	time64_t secs; 	if (!rtc->offset_secs)		return; 	secs = rtc_tm_to_time64(tm); 	/*	 * If the setting time values are in the valid range of RTC hardware	 * device, then no need to subtract the offset when setting time to RTC	 * device. Otherwise we need to subtract the offset to make the time	 * values are valid for RTC hardware device.	 */	if (secs >= rtc->range_min && secs <= rtc->range_max)		return; 	rtc_time64_to_tm(secs - rtc->offset_secs, tm);} static int rtc_valid_range(struct rtc_device *rtc, struct rtc_time *tm){	if (rtc->range_min != rtc->range_max) {		time64_t time = rtc_tm_to_time64(tm);		time64_t range_min = rtc->set_start_time ? rtc->start_secs :			rtc->range_min;		timeu64_t range_max = rtc->set_start_time ?			(rtc->start_secs + rtc->range_max - rtc->range_min) :			rtc->range_max; 		if (time < range_min || time > range_max)			return -ERANGE;	} 	return 0;} static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm){	int err; 	if (!rtc->ops) {		err = -ENODEV;	} else if (!rtc->ops->read_time) {		err = -EINVAL;	} else {		memset(tm, 0, sizeof(struct rtc_time));		err = rtc->ops->read_time(rtc->dev.parent, tm);		if (err < 0) {			dev_dbg(&rtc->dev, "read_time: fail to read: %d\n",				err);			return err;		} 		rtc_add_offset(rtc, tm); 		err = rtc_valid_tm(tm);		if (err < 0)			dev_dbg(&rtc->dev, "read_time: rtc_time isn't valid\n");	}	return err;} int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm){	int err; 	err = mutex_lock_interruptible(&rtc->ops_lock);	if (err)		return err; 	err = __rtc_read_time(rtc, tm);	mutex_unlock(&rtc->ops_lock); 	trace_rtc_read_time(rtc_tm_to_time64(tm), err);	return err;}EXPORT_SYMBOL_GPL(rtc_read_time); int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm){	int err, uie; 	err = rtc_valid_tm(tm);	if (err != 0)		return err; 	err = rtc_valid_range(rtc, tm);	if (err)		return err; 	rtc_subtract_offset(rtc, tm); #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL	uie = rtc->uie_rtctimer.enabled || rtc->uie_irq_active;#else	uie = rtc->uie_rtctimer.enabled;#endif	if (uie) {		err = rtc_update_irq_enable(rtc, 0);		if (err)			return err;	} 	err = mutex_lock_interruptible(&rtc->ops_lock);	if (err)		return err; 	if (!rtc->ops)		err = -ENODEV;	else if (rtc->ops->set_time)		err = rtc->ops->set_time(rtc->dev.parent, tm);	else		err = -EINVAL; 	pm_stay_awake(rtc->dev.parent);	mutex_unlock(&rtc->ops_lock);	/* A timer might have just expired */	schedule_work(&rtc->irqwork); 	if (uie) {		err = rtc_update_irq_enable(rtc, 1);		if (err)			return err;	} 	trace_rtc_set_time(rtc_tm_to_time64(tm), err);	return err;}EXPORT_SYMBOL_GPL(rtc_set_time); static int rtc_read_alarm_internal(struct rtc_device *rtc,				   struct rtc_wkalrm *alarm){	int err; 	err = mutex_lock_interruptible(&rtc->ops_lock);	if (err)		return err; 	if (!rtc->ops) {		err = -ENODEV;	} else if (!test_bit(RTC_FEATURE_ALARM, rtc->features) || !rtc->ops->read_alarm) {		err = -EINVAL;	} else {		alarm->enabled = 0;		alarm->pending = 0;		alarm->time.tm_sec = -1;		alarm->time.tm_min = -1;		alarm->time.tm_hour = -1;		alarm->time.tm_mday = -1;		alarm->time.tm_mon = -1;		alarm->time.tm_year = -1;		alarm->time.tm_wday = -1;		alarm->time.tm_yday = -1;		alarm->time.tm_isdst = -1;		err = rtc->ops->read_alarm(rtc->dev.parent, alarm);	} 	mutex_unlock(&rtc->ops_lock); 	trace_rtc_read_alarm(err?0:rtc_tm_to_time64(&alarm->time), err);	return err;} int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm){	int err;	struct rtc_time before, now;	int first_time = 1;	time64_t t_now, t_alm;	enum { none, day, month, year } missing = none;	unsigned int days; 	/* 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.	 *	 * 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 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; 		/* full-function RTCs won't have such missing fields */		err = rtc_valid_tm(&alarm->time);		if (!err)			goto done; 		/* 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 ||		 before.tm_year != now.tm_year); 	/* Fill in the missing alarm fields using the timestamp; we	 * know there's at least one since alarm->time is invalid.	 */	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; 	/* For simplicity, only support date rollover for now */	if (alarm->time.tm_mday < 1 || alarm->time.tm_mday > 31) {		alarm->time.tm_mday = now.tm_mday;		missing = day;	}	if ((unsigned int)alarm->time.tm_mon >= 12) {		alarm->time.tm_mon = now.tm_mon;		if (missing == none)			missing = month;	}	if (alarm->time.tm_year == -1) {		alarm->time.tm_year = now.tm_year;		if (missing == none)			missing = year;	} 	/* Can't proceed if alarm is still invalid after replacing	 * missing fields.	 */	err = rtc_valid_tm(&alarm->time);	if (err)		goto done; 	/* with luck, no rollover is needed */	t_now = rtc_tm_to_time64(&now);	t_alm = rtc_tm_to_time64(&alarm->time);	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_time64_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++;		} while (!is_leap_year(alarm->time.tm_year + 1900) &&			 rtc_valid_tm(&alarm->time) != 0);		break; 	default:		dev_warn(&rtc->dev, "alarm rollover not handled\n");	} 	err = rtc_valid_tm(&alarm->time); done:	if (err && alarm->enabled)		dev_warn(&rtc->dev, "invalid alarm value: %ptR\n",			 &alarm->time);	else		rtc_add_offset(rtc, &alarm->time); 	return err;} /** * rtc_read_next_alarm - read the next expiring alarm * @rtc: RTC device * @alarm: storage for the alarm information * * Read the next expiring alarm from the RTC timerqueue. This returns * the alarm that will actually fire next, which may be different from * rtc_read_alarm() if multiple timers are queued (e.g., alarmtimer * and wakealarm sysfs both active). * * Returns: 0 on success, -ENOENT if no alarm is pending, or other error. */int rtc_read_next_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm){	struct timerqueue_node *next;	int err; 	if (!rtc || !alarm)		return -EINVAL; 	err = mutex_lock_interruptible(&rtc->ops_lock);	if (err)		return err; 	next = timerqueue_getnext(&rtc->timerqueue);	if (!next) {		err = -ENOENT;		goto unlock;	} 	memset(alarm, 0, sizeof(struct rtc_wkalrm));	alarm->time = rtc_ktime_to_tm(next->expires);	alarm->enabled = 1; unlock:	mutex_unlock(&rtc->ops_lock);	return err;}EXPORT_SYMBOL_GPL(rtc_read_next_alarm); int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm){	int err; 	err = mutex_lock_interruptible(&rtc->ops_lock);	if (err)		return err;	if (!rtc->ops) {		err = -ENODEV;	} else if (!test_bit(RTC_FEATURE_ALARM, rtc->features)) {		err = -EINVAL;	} else {		memset(alarm, 0, sizeof(struct rtc_wkalrm));		alarm->enabled = rtc->aie_timer.enabled;		alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires);	}	mutex_unlock(&rtc->ops_lock); 	trace_rtc_read_alarm(rtc_tm_to_time64(&alarm->time), err);	return err;}EXPORT_SYMBOL_GPL(rtc_read_alarm); static int __rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm){	struct rtc_time tm;	time64_t now, scheduled;	int err; 	err = rtc_valid_tm(&alarm->time);	if (err)		return err; 	scheduled = rtc_tm_to_time64(&alarm->time); 	/* Make sure we're not setting alarms in the past */	err = __rtc_read_time(rtc, &tm);	if (err)		return err;	now = rtc_tm_to_time64(&tm); 	if (scheduled <= now)		return -ETIME;	/*	 * XXX - We just checked to make sure the alarm time is not	 * in the past, but there is still a race window where if	 * the is alarm set for the next second and the second ticks	 * over right here, before we set the alarm.	 */ 	rtc_subtract_offset(rtc, &alarm->time); 	if (!rtc->ops)		err = -ENODEV;	else if (!test_bit(RTC_FEATURE_ALARM, rtc->features))		err = -EINVAL;	else		err = rtc->ops->set_alarm(rtc->dev.parent, alarm); 	/*	 * Check for potential race described above. If the waiting for next	 * second, and the second just ticked since the check above, either	 *	 * 1) It ticked after the alarm was set, and an alarm irq should be	 *    generated.	 *	 * 2) It ticked before the alarm was set, and alarm irq most likely will	 * not be generated.	 *	 * While we cannot easily check for which of these two scenarios we	 * are in, we can return -ETIME to signal that the timer has already	 * expired, which is true in both cases.	 */	if (!err && (scheduled - now) <= 1) {

Lines 1–500 of 1159. Load more