redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

rtc: core: correct trivial checkpatch warnings 

Correct trivial checkpatch warnings, mostly whitespace issues and
unbalanced braces.

Signed-off-by: Alexandre Belloni <alexandre.belloni@bootlin.com>
hifive-unleashed-5.2
Alexandre Belloni 2019-03-20 12:59:09 +01:00
parent 6875404fdb
commit 606cc43c72
8 changed files with 93 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
drivers/rtc/class.c
View File

@ -20,13 +20,13 @@
#include "rtc-core.h" #include "rtc-core.h"
static DEFINE_IDA(rtc_ida); static DEFINE_IDA(rtc_ida);
struct class *rtc_class; struct class *rtc_class;
static void rtc_device_release(struct device *dev) static void rtc_device_release(struct device *dev)
{ {
struct rtc_device *rtc = to_rtc_device(dev); struct rtc_device *rtc = to_rtc_device(dev);
ida_simple_remove(&rtc_ida, rtc->id); ida_simple_remove(&rtc_ida, rtc->id);
kfree(rtc); kfree(rtc);
} }
@ -44,7 +44,6 @@ int rtc_hctosys_ret = -ENODEV;
static struct timespec64 old_rtc, old_system, old_delta; static struct timespec64 old_rtc, old_system, old_delta;
static int rtc_suspend(struct device *dev) static int rtc_suspend(struct device *dev)
{ {
struct rtc_device *rtc = to_rtc_device(dev); struct rtc_device *rtc = to_rtc_device(dev);
@ -68,7 +67,6 @@ static int rtc_suspend(struct device *dev)
ktime_get_real_ts64(&old_system); ktime_get_real_ts64(&old_system);
old_rtc.tv_sec = rtc_tm_to_time64(&tm); old_rtc.tv_sec = rtc_tm_to_time64(&tm);
/* /*
* To avoid drift caused by repeated suspend/resumes, * To avoid drift caused by repeated suspend/resumes,
* which each can add ~1 second drift error, * which each can add ~1 second drift error,
@ -80,7 +78,7 @@ static int rtc_suspend(struct device *dev)
if (delta_delta.tv_sec < -2 || delta_delta.tv_sec >= 2) { if (delta_delta.tv_sec < -2 || delta_delta.tv_sec >= 2) {
/* /*
* if delta_delta is too large, assume time correction * if delta_delta is too large, assume time correction
* has occured and set old_delta to the current delta. * has occurred and set old_delta to the current delta.
*/ */
old_delta = delta; old_delta = delta;
} else { } else {
@ -133,7 +131,7 @@ static int rtc_resume(struct device *dev)
* to keep things accurate. * to keep things accurate.
*/ */
sleep_time = timespec64_sub(sleep_time, sleep_time = timespec64_sub(sleep_time,
timespec64_sub(new_system, old_system)); timespec64_sub(new_system, old_system));
if (sleep_time.tv_sec >= 0) if (sleep_time.tv_sec >= 0)
timekeeping_inject_sleeptime64(&sleep_time); timekeeping_inject_sleeptime64(&sleep_time);
@ -394,9 +392,9 @@ EXPORT_SYMBOL_GPL(__rtc_register_device);
* rtc_register_device instead * rtc_register_device instead
*/ */
struct rtc_device *devm_rtc_device_register(struct device *dev, struct rtc_device *devm_rtc_device_register(struct device *dev,
const char *name, const char *name,
const struct rtc_class_ops *ops, const struct rtc_class_ops *ops,
struct module *owner) struct module *owner)
{ {
struct rtc_device *rtc; struct rtc_device *rtc;
int err; int err;

13
drivers/rtc/dev.c
View File

@ -57,7 +57,7 @@ static void rtc_uie_task(struct work_struct *work)
} else if (rtc->oldsecs != tm.tm_sec) { } else if (rtc->oldsecs != tm.tm_sec) {
num = (tm.tm_sec + 60 - rtc->oldsecs) % 60; num = (tm.tm_sec + 60 - rtc->oldsecs) % 60;
rtc->oldsecs = tm.tm_sec; rtc->oldsecs = tm.tm_sec;
rtc->uie_timer.expires = jiffies + HZ - (HZ/10); rtc->uie_timer.expires = jiffies + HZ - (HZ / 10);
rtc->uie_timer_active = 1; rtc->uie_timer_active = 1;
rtc->uie_task_active = 0; rtc->uie_task_active = 0;
add_timer(&rtc->uie_timer); add_timer(&rtc->uie_timer);
@ -68,6 +68,7 @@ static void rtc_uie_task(struct work_struct *work)
if (num) if (num)
rtc_handle_legacy_irq(rtc, num, RTC_UF); rtc_handle_legacy_irq(rtc, num, RTC_UF);
} }
static void rtc_uie_timer(struct timer_list *t) static void rtc_uie_timer(struct timer_list *t)
{ {
struct rtc_device *rtc = from_timer(rtc, t, uie_timer); struct rtc_device *rtc = from_timer(rtc, t, uie_timer);
@ -199,14 +200,14 @@ static __poll_t rtc_dev_poll(struct file *file, poll_table *wait)
} }
static long rtc_dev_ioctl(struct file *file, static long rtc_dev_ioctl(struct file *file,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
int err = 0; int err = 0;
struct rtc_device *rtc = file->private_data; struct rtc_device *rtc = file->private_data;
const struct rtc_class_ops *ops = rtc->ops; const struct rtc_class_ops *ops = rtc->ops;
struct rtc_time tm; struct rtc_time tm;
struct rtc_wkalrm alarm; struct rtc_wkalrm alarm;
void __user *uarg = (void __user *) arg; void __user *uarg = (void __user *)arg;
err = mutex_lock_interruptible(&rtc->ops_lock); err = mutex_lock_interruptible(&rtc->ops_lock);
if (err) if (err)
@ -230,7 +231,7 @@ static long rtc_dev_ioctl(struct file *file,
case RTC_PIE_ON: case RTC_PIE_ON:
if (rtc->irq_freq > rtc->max_user_freq && if (rtc->irq_freq > rtc->max_user_freq &&
!capable(CAP_SYS_RESOURCE)) !capable(CAP_SYS_RESOURCE))
err = -EACCES; err = -EACCES;
break; break;
} }
@ -387,8 +388,9 @@ static long rtc_dev_ioctl(struct file *file,
err = ops->ioctl(rtc->dev.parent, cmd, arg); err = ops->ioctl(rtc->dev.parent, cmd, arg);
if (err == -ENOIOCTLCMD) if (err == -ENOIOCTLCMD)
err = -ENOTTY; err = -ENOTTY;
} else } else {
err = -ENOTTY; err = -ENOTTY;
}
break; break;
} }
@ -400,6 +402,7 @@ done:
static int rtc_dev_fasync(int fd, struct file *file, int on) static int rtc_dev_fasync(int fd, struct file *file, int on)
{ {
struct rtc_device *rtc = file->private_data; struct rtc_device *rtc = file->private_data;
return fasync_helper(fd, file, on, &rtc->async_queue); return fasync_helper(fd, file, on, &rtc->async_queue);
} }

3
drivers/rtc/hctosys.c
View File

@ -30,7 +30,7 @@ static int __init rtc_hctosys(void)
}; };
struct rtc_device *rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE); struct rtc_device *rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
if (rtc == NULL) { if (!rtc) {
pr_info("unable to open rtc device (%s)\n", pr_info("unable to open rtc device (%s)\n",
CONFIG_RTC_HCTOSYS_DEVICE); CONFIG_RTC_HCTOSYS_DEVICE);
goto err_open; goto err_open;
@ -41,7 +41,6 @@ static int __init rtc_hctosys(void)
dev_err(rtc->dev.parent, dev_err(rtc->dev.parent,
"hctosys: unable to read the hardware clock\n"); "hctosys: unable to read the hardware clock\n");
goto err_read; goto err_read;
} }
tv64.tv_sec = rtc_tm_to_time64(&tm); tv64.tv_sec = rtc_tm_to_time64(&tm);

99
drivers/rtc/interface.c
View File

@ -84,11 +84,12 @@ static int rtc_valid_range(struct rtc_device *rtc, struct rtc_time *tm)
static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm) static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
{ {
int err; int err;
if (!rtc->ops)
if (!rtc->ops) {
err = -ENODEV; err = -ENODEV;
else if (!rtc->ops->read_time) } else if (!rtc->ops->read_time) {
err = -EINVAL; err = -EINVAL;
else { } else {
memset(tm, 0, sizeof(struct rtc_time)); memset(tm, 0, sizeof(struct rtc_time));
err = rtc->ops->read_time(rtc->dev.parent, tm); err = rtc->ops->read_time(rtc->dev.parent, tm);
if (err < 0) { if (err < 0) {
@ -144,14 +145,13 @@ int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
err = -ENODEV; err = -ENODEV;
else if (rtc->ops->set_time) else if (rtc->ops->set_time)
err = rtc->ops->set_time(rtc->dev.parent, tm); err = rtc->ops->set_time(rtc->dev.parent, tm);
else if (rtc->ops->set_mmss64) { else if (rtc->ops->set_mmss64)
time64_t secs64 = rtc_tm_to_time64(tm); err = rtc->ops->set_mmss64(rtc->dev.parent,
rtc_tm_to_time64(tm));
err = rtc->ops->set_mmss64(rtc->dev.parent, secs64); else if (rtc->ops->set_mmss)
} else if (rtc->ops->set_mmss) { err = rtc->ops->set_mmss(rtc->dev.parent,
time64_t secs64 = rtc_tm_to_time64(tm); rtc_tm_to_time64(tm));
err = rtc->ops->set_mmss(rtc->dev.parent, secs64); else
} else
err = -EINVAL; err = -EINVAL;
pm_stay_awake(rtc->dev.parent); pm_stay_awake(rtc->dev.parent);
@ -164,7 +164,8 @@ int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
} }
EXPORT_SYMBOL_GPL(rtc_set_time); EXPORT_SYMBOL_GPL(rtc_set_time);
static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm) static int rtc_read_alarm_internal(struct rtc_device *rtc,
struct rtc_wkalrm *alarm)
{ {
int err; int err;
@ -172,11 +173,11 @@ static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *al
if (err) if (err)
return err; return err;
if (rtc->ops == NULL) if (!rtc->ops) {
err = -ENODEV; err = -ENODEV;
else if (!rtc->ops->read_alarm) } else if (!rtc->ops->read_alarm) {
err = -EINVAL; err = -EINVAL;
else { } else {
alarm->enabled = 0; alarm->enabled = 0;
alarm->pending = 0; alarm->pending = 0;
alarm->time.tm_sec = -1; alarm->time.tm_sec = -1;
@ -204,7 +205,7 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
int first_time = 1; int first_time = 1;
time64_t t_now, t_alm; time64_t t_now, t_alm;
enum { none, day, month, year } missing = none; enum { none, day, month, year } missing = none;
unsigned days; unsigned int days;
/* The lower level RTC driver may return -1 in some fields, /* The lower level RTC driver may return -1 in some fields,
* creating invalid alarm->time values, for reasons like: * creating invalid alarm->time values, for reasons like:
@ -273,10 +274,10 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
return err; return err;
/* note that tm_sec is a "don't care" value here: */ /* note that tm_sec is a "don't care" value here: */
} while ( before.tm_min != now.tm_min } while (before.tm_min != now.tm_min ||
|| before.tm_hour != now.tm_hour before.tm_hour != now.tm_hour ||
|| before.tm_mon != now.tm_mon before.tm_mon != now.tm_mon ||
|| before.tm_year != now.tm_year); before.tm_year != now.tm_year);
/* Fill in the missing alarm fields using the timestamp; we /* Fill in the missing alarm fields using the timestamp; we
* know there's at least one since alarm->time is invalid. * know there's at least one since alarm->time is invalid.
@ -293,7 +294,7 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
alarm->time.tm_mday = now.tm_mday; alarm->time.tm_mday = now.tm_mday;
missing = day; missing = day;
} }
if ((unsigned)alarm->time.tm_mon >= 12) { if ((unsigned int)alarm->time.tm_mon >= 12) {
alarm->time.tm_mon = now.tm_mon; alarm->time.tm_mon = now.tm_mon;
if (missing == none) if (missing == none)
missing = month; missing = month;
@ -318,7 +319,6 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
goto done; goto done;
switch (missing) { switch (missing) {
/* 24 hour rollover ... if it's now 10am Monday, an alarm that /* 24 hour rollover ... if it's now 10am Monday, an alarm that
* that will trigger at 5am will do so at 5am Tuesday, which * 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 * could also be in the next month or year. This is a common
@ -338,14 +338,14 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
case month: case month:
dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month"); dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month");
do { do {
if (alarm->time.tm_mon < 11) if (alarm->time.tm_mon < 11) {
alarm->time.tm_mon++; alarm->time.tm_mon++;
else { } else {
alarm->time.tm_mon = 0; alarm->time.tm_mon = 0;
alarm->time.tm_year++; alarm->time.tm_year++;
} }
days = rtc_month_days(alarm->time.tm_mon, days = rtc_month_days(alarm->time.tm_mon,
alarm->time.tm_year); alarm->time.tm_year);
} while (days < alarm->time.tm_mday); } while (days < alarm->time.tm_mday);
break; break;
@ -354,8 +354,8 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year"); dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year");
do { do {
alarm->time.tm_year++; alarm->time.tm_year++;
} while (!is_leap_year(alarm->time.tm_year + 1900) } while (!is_leap_year(alarm->time.tm_year + 1900) &&
&& rtc_valid_tm(&alarm->time) != 0); rtc_valid_tm(&alarm->time) != 0);
break; break;
default: default:
@ -366,7 +366,8 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
done: done:
if (err) if (err)
dev_warn(&rtc->dev, "invalid alarm value: %ptR\n", &alarm->time); dev_warn(&rtc->dev, "invalid alarm value: %ptR\n",
&alarm->time);
return err; return err;
} }
@ -378,11 +379,11 @@ int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
err = mutex_lock_interruptible(&rtc->ops_lock); err = mutex_lock_interruptible(&rtc->ops_lock);
if (err) if (err)
return err; return err;
if (rtc->ops == NULL) if (!rtc->ops) {
err = -ENODEV; err = -ENODEV;
else if (!rtc->ops->read_alarm) } else if (!rtc->ops->read_alarm) {
err = -EINVAL; err = -EINVAL;
else { } else {
memset(alarm, 0, sizeof(struct rtc_wkalrm)); memset(alarm, 0, sizeof(struct rtc_wkalrm));
alarm->enabled = rtc->aie_timer.enabled; alarm->enabled = rtc->aie_timer.enabled;
alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires); alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires);
@ -491,7 +492,6 @@ int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
/* Alarm has to be enabled & in the future for us to enqueue it */ /* Alarm has to be enabled & in the future for us to enqueue it */
if (alarm->enabled && (rtc_tm_to_ktime(now) < if (alarm->enabled && (rtc_tm_to_ktime(now) <
rtc->aie_timer.node.expires)) { rtc->aie_timer.node.expires)) {
rtc->aie_timer.enabled = 1; rtc->aie_timer.enabled = 1;
timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node); timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node);
trace_rtc_timer_enqueue(&rtc->aie_timer); trace_rtc_timer_enqueue(&rtc->aie_timer);
@ -503,7 +503,9 @@ EXPORT_SYMBOL_GPL(rtc_initialize_alarm);
int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled) int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
{ {
int err = mutex_lock_interruptible(&rtc->ops_lock); int err;
err = mutex_lock_interruptible(&rtc->ops_lock);
if (err) if (err)
return err; return err;
@ -532,7 +534,9 @@ EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable);
int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled) int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
{ {
int err = mutex_lock_interruptible(&rtc->ops_lock); int err;
err = mutex_lock_interruptible(&rtc->ops_lock);
if (err) if (err)
return err; return err;
@ -561,8 +565,9 @@ int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
rtc->uie_rtctimer.node.expires = ktime_add(now, onesec); rtc->uie_rtctimer.node.expires = ktime_add(now, onesec);
rtc->uie_rtctimer.period = ktime_set(1, 0); rtc->uie_rtctimer.period = ktime_set(1, 0);
err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer); err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
} else } else {
rtc_timer_remove(rtc, &rtc->uie_rtctimer); rtc_timer_remove(rtc, &rtc->uie_rtctimer);
}
out: out:
mutex_unlock(&rtc->ops_lock); mutex_unlock(&rtc->ops_lock);
@ -577,11 +582,9 @@ out:
err = rtc_dev_update_irq_enable_emul(rtc, enabled); err = rtc_dev_update_irq_enable_emul(rtc, enabled);
#endif #endif
return err; return err;
} }
EXPORT_SYMBOL_GPL(rtc_update_irq_enable); EXPORT_SYMBOL_GPL(rtc_update_irq_enable);
/** /**
* rtc_handle_legacy_irq - AIE, UIE and PIE event hook * rtc_handle_legacy_irq - AIE, UIE and PIE event hook
* @rtc: pointer to the rtc device * @rtc: pointer to the rtc device
@ -596,14 +599,13 @@ void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode)
/* mark one irq of the appropriate mode */ /* mark one irq of the appropriate mode */
spin_lock_irqsave(&rtc->irq_lock, flags); spin_lock_irqsave(&rtc->irq_lock, flags);
rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF|mode); rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF | mode);
spin_unlock_irqrestore(&rtc->irq_lock, flags); spin_unlock_irqrestore(&rtc->irq_lock, flags);
wake_up_interruptible(&rtc->irq_queue); wake_up_interruptible(&rtc->irq_queue);
kill_fasync(&rtc->async_queue, SIGIO, POLL_IN); kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
} }
/** /**
* rtc_aie_update_irq - AIE mode rtctimer hook * rtc_aie_update_irq - AIE mode rtctimer hook
* @rtc: pointer to the rtc_device * @rtc: pointer to the rtc_device
@ -615,7 +617,6 @@ void rtc_aie_update_irq(struct rtc_device *rtc)
rtc_handle_legacy_irq(rtc, 1, RTC_AF); rtc_handle_legacy_irq(rtc, 1, RTC_AF);
} }
/** /**
* rtc_uie_update_irq - UIE mode rtctimer hook * rtc_uie_update_irq - UIE mode rtctimer hook
* @rtc: pointer to the rtc_device * @rtc: pointer to the rtc_device
@ -627,7 +628,6 @@ void rtc_uie_update_irq(struct rtc_device *rtc)
rtc_handle_legacy_irq(rtc, 1, RTC_UF); rtc_handle_legacy_irq(rtc, 1, RTC_UF);
} }
/** /**
* rtc_pie_update_irq - PIE mode hrtimer hook * rtc_pie_update_irq - PIE mode hrtimer hook
* @timer: pointer to the pie mode hrtimer * @timer: pointer to the pie mode hrtimer
@ -641,6 +641,7 @@ enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
struct rtc_device *rtc; struct rtc_device *rtc;
ktime_t period; ktime_t period;
int count; int count;
rtc = container_of(timer, struct rtc_device, pie_timer); rtc = container_of(timer, struct rtc_device, pie_timer);
period = NSEC_PER_SEC / rtc->irq_freq; period = NSEC_PER_SEC / rtc->irq_freq;
@ -659,7 +660,7 @@ enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
* Context: any * Context: any
*/ */
void rtc_update_irq(struct rtc_device *rtc, void rtc_update_irq(struct rtc_device *rtc,
unsigned long num, unsigned long events) unsigned long num, unsigned long events)
{ {
if (IS_ERR_OR_NULL(rtc)) if (IS_ERR_OR_NULL(rtc))
return; return;
@ -808,6 +809,7 @@ static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
if (!next || ktime_before(timer->node.expires, next->expires)) { if (!next || ktime_before(timer->node.expires, next->expires)) {
struct rtc_wkalrm alarm; struct rtc_wkalrm alarm;
int err; int err;
alarm.time = rtc_ktime_to_tm(timer->node.expires); alarm.time = rtc_ktime_to_tm(timer->node.expires);
alarm.enabled = 1; alarm.enabled = 1;
err = __rtc_set_alarm(rtc, &alarm); err = __rtc_set_alarm(rtc, &alarm);
@ -848,12 +850,14 @@ static void rtc_alarm_disable(struct rtc_device *rtc)
static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer) static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
{ {
struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue); struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
timerqueue_del(&rtc->timerqueue, &timer->node); timerqueue_del(&rtc->timerqueue, &timer->node);
trace_rtc_timer_dequeue(timer); trace_rtc_timer_dequeue(timer);
timer->enabled = 0; timer->enabled = 0;
if (next == &timer->node) { if (next == &timer->node) {
struct rtc_wkalrm alarm; struct rtc_wkalrm alarm;
int err; int err;
next = timerqueue_getnext(&rtc->timerqueue); next = timerqueue_getnext(&rtc->timerqueue);
if (!next) { if (!next) {
rtc_alarm_disable(rtc); rtc_alarm_disable(rtc);
@ -926,9 +930,9 @@ again:
alarm.enabled = 1; alarm.enabled = 1;
reprogram: reprogram:
err = __rtc_set_alarm(rtc, &alarm); err = __rtc_set_alarm(rtc, &alarm);
if (err == -ETIME) if (err == -ETIME) {
goto again; goto again;
else if (err) { } else if (err) {
if (retry-- > 0) if (retry-- > 0)
goto reprogram; goto reprogram;
@ -939,14 +943,14 @@ reprogram:
dev_err(&rtc->dev, "__rtc_set_alarm: err=%d\n", err); dev_err(&rtc->dev, "__rtc_set_alarm: err=%d\n", err);
goto again; goto again;
} }
} else } else {
rtc_alarm_disable(rtc); rtc_alarm_disable(rtc);
}
pm_relax(rtc->dev.parent); pm_relax(rtc->dev.parent);
mutex_unlock(&rtc->ops_lock); mutex_unlock(&rtc->ops_lock);
} }
/* rtc_timer_init - Initializes an rtc_timer /* rtc_timer_init - Initializes an rtc_timer
* @timer: timer to be intiialized * @timer: timer to be intiialized
* @f: function pointer to be called when timer fires * @f: function pointer to be called when timer fires
@ -972,9 +976,10 @@ void rtc_timer_init(struct rtc_timer *timer, void (*f)(struct rtc_device *r),
* Kernel interface to set an rtc_timer * Kernel interface to set an rtc_timer
*/ */
int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer, int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer,
ktime_t expires, ktime_t period) ktime_t expires, ktime_t period)
{ {
int ret = 0; int ret = 0;
mutex_lock(&rtc->ops_lock); mutex_lock(&rtc->ops_lock);
if (timer->enabled) if (timer->enabled)
rtc_timer_remove(rtc, timer); rtc_timer_remove(rtc, timer);

22
drivers/rtc/lib.c
View File

@ -22,7 +22,7 @@ static const unsigned short rtc_ydays[2][13] = {
{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 } { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
}; };
#define LEAPS_THRU_END_OF(y) ((y)/4 - (y)/100 + (y)/400) #define LEAPS_THRU_END_OF(y) ((y) / 4 - (y) / 100 + (y) / 400)
/* /*
* The number of days in the month. * The number of days in the month.
@ -38,11 +38,10 @@ EXPORT_SYMBOL(rtc_month_days);
*/ */
int rtc_year_days(unsigned int day, unsigned int month, unsigned int year) int rtc_year_days(unsigned int day, unsigned int month, unsigned int year)
{ {
return rtc_ydays[is_leap_year(year)][month] + day-1; return rtc_ydays[is_leap_year(year)][month] + day - 1;
} }
EXPORT_SYMBOL(rtc_year_days); EXPORT_SYMBOL(rtc_year_days);
/* /*
* rtc_time64_to_tm - Converts time64_t to rtc_time. * rtc_time64_to_tm - Converts time64_t to rtc_time.
* Convert seconds since 01-01-1970 00:00:00 to Gregorian date. * Convert seconds since 01-01-1970 00:00:00 to Gregorian date.
@ -94,13 +93,14 @@ EXPORT_SYMBOL(rtc_time64_to_tm);
*/ */
int rtc_valid_tm(struct rtc_time *tm) int rtc_valid_tm(struct rtc_time *tm)
{ {
if (tm->tm_year < 70 if (tm->tm_year < 70 ||
|| ((unsigned)tm->tm_mon) >= 12 ((unsigned int)tm->tm_mon) >= 12 ||
|| tm->tm_mday < 1 tm->tm_mday < 1 ||
|| tm->tm_mday > rtc_month_days(tm->tm_mon, ((unsigned)tm->tm_year + 1900)) tm->tm_mday > rtc_month_days(tm->tm_mon,
|| ((unsigned)tm->tm_hour) >= 24 ((unsigned int)tm->tm_year + 1900)) ||
|| ((unsigned)tm->tm_min) >= 60 ((unsigned int)tm->tm_hour) >= 24 ||
|| ((unsigned)tm->tm_sec) >= 60) ((unsigned int)tm->tm_min) >= 60 ||
((unsigned int)tm->tm_sec) >= 60)
return -EINVAL; return -EINVAL;
return 0; return 0;
@ -113,7 +113,7 @@ EXPORT_SYMBOL(rtc_valid_tm);
*/ */
time64_t rtc_tm_to_time64(struct rtc_time *tm) time64_t rtc_tm_to_time64(struct rtc_time *tm)
{ {
return mktime64(((unsigned)tm->tm_year + 1900), tm->tm_mon + 1, return mktime64(((unsigned int)tm->tm_year + 1900), tm->tm_mon + 1,
tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec); tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
} }
EXPORT_SYMBOL(rtc_tm_to_time64); EXPORT_SYMBOL(rtc_tm_to_time64);

2
drivers/rtc/nvmem.c
View File

@ -43,7 +43,7 @@ static int rtc_nvram_register(struct rtc_device *rtc,
{ {
int err; int err;
rtc->nvram = kzalloc(sizeof(struct bin_attribute), GFP_KERNEL); rtc->nvram = kzalloc(sizeof(*rtc->nvram), GFP_KERNEL);
if (!rtc->nvram) if (!rtc->nvram)
return -ENOMEM; return -ENOMEM;

14
drivers/rtc/proc.c
View File

@ -57,17 +57,17 @@ static int rtc_proc_show(struct seq_file *seq, void *offset)
seq_printf(seq, "alrm_time\t: %ptRt\n", &alrm.time); seq_printf(seq, "alrm_time\t: %ptRt\n", &alrm.time);
seq_printf(seq, "alrm_date\t: %ptRd\n", &alrm.time); seq_printf(seq, "alrm_date\t: %ptRd\n", &alrm.time);
seq_printf(seq, "alarm_IRQ\t: %s\n", seq_printf(seq, "alarm_IRQ\t: %s\n",
alrm.enabled ? "yes" : "no"); alrm.enabled ? "yes" : "no");
seq_printf(seq, "alrm_pending\t: %s\n", seq_printf(seq, "alrm_pending\t: %s\n",
alrm.pending ? "yes" : "no"); alrm.pending ? "yes" : "no");
seq_printf(seq, "update IRQ enabled\t: %s\n", seq_printf(seq, "update IRQ enabled\t: %s\n",
(rtc->uie_rtctimer.enabled) ? "yes" : "no"); (rtc->uie_rtctimer.enabled) ? "yes" : "no");
seq_printf(seq, "periodic IRQ enabled\t: %s\n", seq_printf(seq, "periodic IRQ enabled\t: %s\n",
(rtc->pie_enabled) ? "yes" : "no"); (rtc->pie_enabled) ? "yes" : "no");
seq_printf(seq, "periodic IRQ frequency\t: %d\n", seq_printf(seq, "periodic IRQ frequency\t: %d\n",
rtc->irq_freq); rtc->irq_freq);
seq_printf(seq, "max user IRQ frequency\t: %d\n", seq_printf(seq, "max user IRQ frequency\t: %d\n",
rtc->max_user_freq); rtc->max_user_freq);
} }
seq_printf(seq, "24hr\t\t: yes\n"); seq_printf(seq, "24hr\t\t: yes\n");
@ -82,7 +82,7 @@ void rtc_proc_add_device(struct rtc_device *rtc)
{ {
if (is_rtc_hctosys(rtc)) if (is_rtc_hctosys(rtc))
proc_create_single_data("driver/rtc", 0, NULL, rtc_proc_show, proc_create_single_data("driver/rtc", 0, NULL, rtc_proc_show,
rtc); rtc);
} }
void rtc_proc_del_device(struct rtc_device *rtc) void rtc_proc_del_device(struct rtc_device *rtc)

16
drivers/rtc/sysfs.c
View File

@ -11,7 +11,6 @@
#include "rtc-core.h" #include "rtc-core.h"
/* device attributes */ /* device attributes */
/* /*
@ -83,7 +82,7 @@ max_user_freq_show(struct device *dev, struct device_attribute *attr, char *buf)
static ssize_t static ssize_t
max_user_freq_store(struct device *dev, struct device_attribute *attr, max_user_freq_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t n) const char *buf, size_t n)
{ {
struct rtc_device *rtc = to_rtc_device(dev); struct rtc_device *rtc = to_rtc_device(dev);
unsigned long val; unsigned long val;
@ -113,12 +112,11 @@ hctosys_show(struct device *dev, struct device_attribute *attr, char *buf)
{ {
#ifdef CONFIG_RTC_HCTOSYS_DEVICE #ifdef CONFIG_RTC_HCTOSYS_DEVICE
if (rtc_hctosys_ret == 0 && if (rtc_hctosys_ret == 0 &&
strcmp(dev_name(&to_rtc_device(dev)->dev), strcmp(dev_name(&to_rtc_device(dev)->dev),
CONFIG_RTC_HCTOSYS_DEVICE) == 0) CONFIG_RTC_HCTOSYS_DEVICE) == 0)
return sprintf(buf, "1\n"); return sprintf(buf, "1\n");
else
#endif #endif
return sprintf(buf, "0\n"); return sprintf(buf, "0\n");
} }
static DEVICE_ATTR_RO(hctosys); static DEVICE_ATTR_RO(hctosys);
@ -172,15 +170,15 @@ wakealarm_store(struct device *dev, struct device_attribute *attr,
if (*buf_ptr == '=') { if (*buf_ptr == '=') {
buf_ptr++; buf_ptr++;
push = 1; push = 1;
} else } else {
adjust = 1; adjust = 1;
}
} }
retval = kstrtos64(buf_ptr, 0, &alarm); retval = kstrtos64(buf_ptr, 0, &alarm);
if (retval) if (retval)
return retval; return retval;
if (adjust) { if (adjust)
alarm += now; alarm += now;
}
if (alarm > now || push) { if (alarm > now || push) {
/* Avoid accidentally clobbering active alarms; we can't /* Avoid accidentally clobbering active alarms; we can't
* entirely prevent that here, without even the minimal * entirely prevent that here, without even the minimal