Commit 606cc43c authored by Alexandre Belloni's avatar Alexandre Belloni
Browse files

rtc: core: correct trivial checkpatch warnings 



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

Signed-off-by: default avatarAlexandre Belloni <alexandre.belloni@bootlin.com>
parent 6875404f

drivers/rtc/class.c

+6 −8
Original line number Diff line number Diff line
@@ -20,13 +20,13 @@ 


#include "rtc-core.h"





static DEFINE_IDA(rtc_ida);

struct class *rtc_class;



static void rtc_device_release(struct device *dev)

{

	struct rtc_device *rtc = to_rtc_device(dev);



	ida_simple_remove(&rtc_ida, rtc->id);

	kfree(rtc);

}
@@ -44,7 +44,6 @@ int rtc_hctosys_ret = -ENODEV; 


static struct timespec64 old_rtc, old_system, old_delta;





static int rtc_suspend(struct 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);

	old_rtc.tv_sec = rtc_tm_to_time64(&tm);





	/*

	 * To avoid drift caused by repeated suspend/resumes,

	 * 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 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;

	} else {

drivers/rtc/dev.c

+8 −5
Original line number Diff line number Diff line
@@ -68,6 +68,7 @@ static void rtc_uie_task(struct work_struct *work) 
	if (num)

		rtc_handle_legacy_irq(rtc, num, RTC_UF);

}



static void rtc_uie_timer(struct timer_list *t)

{

	struct rtc_device *rtc = from_timer(rtc, t, uie_timer);
@@ -387,8 +388,9 @@ static long rtc_dev_ioctl(struct file *file, 
			err = ops->ioctl(rtc->dev.parent, cmd, arg);

			if (err == -ENOIOCTLCMD)

				err = -ENOTTY;

		} else

		} else {

			err = -ENOTTY;

		}

		break;

	}
@@ -400,6 +402,7 @@ static long rtc_dev_ioctl(struct file *file, 
static int rtc_dev_fasync(int fd, struct file *file, int on)

{

	struct rtc_device *rtc = file->private_data;



	return fasync_helper(fd, file, on, &rtc->async_queue);

}

drivers/rtc/hctosys.c

+1 −2
Original line number Diff line number Diff line
@@ -30,7 +30,7 @@ static int __init rtc_hctosys(void) 
	};

	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",

			CONFIG_RTC_HCTOSYS_DEVICE);

		goto err_open;
@@ -41,7 +41,6 @@ static int __init rtc_hctosys(void) 
		dev_err(rtc->dev.parent,

			"hctosys: unable to read the hardware clock\n");

		goto err_read;



	}



	tv64.tv_sec = rtc_tm_to_time64(&tm);

drivers/rtc/interface.c

+52 −47
Original line number Diff line number Diff line
@@ -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)

{

	int err;

	if (!rtc->ops)



	if (!rtc->ops) {

		err = -ENODEV;

	else if (!rtc->ops->read_time)

	} else if (!rtc->ops->read_time) {

		err = -EINVAL;

	else {

	} else {

		memset(tm, 0, sizeof(struct rtc_time));

		err = rtc->ops->read_time(rtc->dev.parent, tm);

		if (err < 0) {
@@ -144,14 +145,13 @@ int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm) 
		err = -ENODEV;

	else if (rtc->ops->set_time)

		err = rtc->ops->set_time(rtc->dev.parent, tm);

	else if (rtc->ops->set_mmss64) {

		time64_t secs64 = rtc_tm_to_time64(tm);



		err = rtc->ops->set_mmss64(rtc->dev.parent, secs64);

	} else if (rtc->ops->set_mmss) {

		time64_t secs64 = rtc_tm_to_time64(tm);

		err = rtc->ops->set_mmss(rtc->dev.parent, secs64);

	} else

	else if (rtc->ops->set_mmss64)

		err = rtc->ops->set_mmss64(rtc->dev.parent,

					   rtc_tm_to_time64(tm));

	else if (rtc->ops->set_mmss)

		err = rtc->ops->set_mmss(rtc->dev.parent,

					 rtc_tm_to_time64(tm));

	else

		err = -EINVAL;



	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);



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;
@@ -172,11 +173,11 @@ static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *al 
	if (err)

		return err;



	if (rtc->ops == NULL)

	if (!rtc->ops) {

		err = -ENODEV;

	else if (!rtc->ops->read_alarm)

	} else if (!rtc->ops->read_alarm) {

		err = -EINVAL;

	else {

	} else {

		alarm->enabled = 0;

		alarm->pending = 0;

		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;

	time64_t t_now, t_alm;

	enum { none, day, month, year } missing = none;

	unsigned days;

	unsigned int days;



	/* The lower level RTC driver may return -1 in some fields,

	 * 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;



		/* 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);

	} 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.
@@ -293,7 +294,7 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 
		alarm->time.tm_mday = now.tm_mday;

		missing = day;

	}

	if ((unsigned)alarm->time.tm_mon >= 12) {

	if ((unsigned int)alarm->time.tm_mon >= 12) {

		alarm->time.tm_mon = now.tm_mon;

		if (missing == none)

			missing = month;
@@ -318,7 +319,6 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 
		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
@@ -338,9 +338,9 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 
	case month:

		dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month");

		do {

			if (alarm->time.tm_mon < 11)

			if (alarm->time.tm_mon < 11) {

				alarm->time.tm_mon++;

			else {

			} else {

				alarm->time.tm_mon = 0;

				alarm->time.tm_year++;

			}
@@ -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");

		do {

			alarm->time.tm_year++;

		} while (!is_leap_year(alarm->time.tm_year + 1900)

			&& rtc_valid_tm(&alarm->time) != 0);

		} while (!is_leap_year(alarm->time.tm_year + 1900) &&

			 rtc_valid_tm(&alarm->time) != 0);

		break;



	default:
@@ -366,7 +366,8 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 


done:

	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;

}
@@ -378,11 +379,11 @@ int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 
	err = mutex_lock_interruptible(&rtc->ops_lock);

	if (err)

		return err;

	if (rtc->ops == NULL)

	if (!rtc->ops) {

		err = -ENODEV;

	else if (!rtc->ops->read_alarm)

	} else if (!rtc->ops->read_alarm) {

		err = -EINVAL;

	else {

	} 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);
@@ -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 */

	if (alarm->enabled && (rtc_tm_to_ktime(now) <

			 rtc->aie_timer.node.expires)) {



		rtc->aie_timer.enabled = 1;

		timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node);

		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 err = mutex_lock_interruptible(&rtc->ops_lock);

	int err;



	err = mutex_lock_interruptible(&rtc->ops_lock);

	if (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 err = mutex_lock_interruptible(&rtc->ops_lock);

	int err;



	err = mutex_lock_interruptible(&rtc->ops_lock);

	if (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.period = ktime_set(1, 0);

		err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);

	} else

	} else {

		rtc_timer_remove(rtc, &rtc->uie_rtctimer);

	}



out:

	mutex_unlock(&rtc->ops_lock);
@@ -577,11 +582,9 @@ int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled) 
		err = rtc_dev_update_irq_enable_emul(rtc, enabled);

#endif

	return err;



}

EXPORT_SYMBOL_GPL(rtc_update_irq_enable);





/**

 * rtc_handle_legacy_irq - AIE, UIE and PIE event hook

 * @rtc: pointer to the rtc device
@@ -603,7 +606,6 @@ void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode) 
	kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);

}





/**

 * rtc_aie_update_irq - AIE mode rtctimer hook

 * @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_uie_update_irq - UIE mode rtctimer hook

 * @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_pie_update_irq - PIE mode hrtimer hook

 * @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;

	ktime_t period;

	int count;



	rtc = container_of(timer, struct rtc_device, pie_timer);



	period = NSEC_PER_SEC / rtc->irq_freq;
@@ -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)) {

		struct rtc_wkalrm alarm;

		int err;



		alarm.time = rtc_ktime_to_tm(timer->node.expires);

		alarm.enabled = 1;

		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)

{

	struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);



	timerqueue_del(&rtc->timerqueue, &timer->node);

	trace_rtc_timer_dequeue(timer);

	timer->enabled = 0;

	if (next == &timer->node) {

		struct rtc_wkalrm alarm;

		int err;



		next = timerqueue_getnext(&rtc->timerqueue);

		if (!next) {

			rtc_alarm_disable(rtc);
@@ -926,9 +930,9 @@ void rtc_timer_do_work(struct work_struct *work) 
		alarm.enabled = 1;

reprogram:

		err = __rtc_set_alarm(rtc, &alarm);

		if (err == -ETIME)

		if (err == -ETIME) {

			goto again;

		else if (err) {

		} else if (err) {

			if (retry-- > 0)

				goto reprogram;
@@ -939,14 +943,14 @@ void rtc_timer_do_work(struct work_struct *work) 
			dev_err(&rtc->dev, "__rtc_set_alarm: err=%d\n", err);

			goto again;

		}

	} else

	} else {

		rtc_alarm_disable(rtc);

	}



	pm_relax(rtc->dev.parent);

	mutex_unlock(&rtc->ops_lock);

}





/* rtc_timer_init - Initializes an rtc_timer

 * @timer: timer to be intiialized

 * @f: function pointer to be called when timer fires
@@ -975,6 +979,7 @@ int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer, 
		    ktime_t expires, ktime_t period)

{

	int ret = 0;



	mutex_lock(&rtc->ops_lock);

	if (timer->enabled)

		rtc_timer_remove(rtc, timer);

drivers/rtc/lib.c

+11 −11
Original line number Diff line number Diff line
@@ -42,7 +42,6 @@ int rtc_year_days(unsigned int day, unsigned int month, unsigned int year) 
}

EXPORT_SYMBOL(rtc_year_days);





/*

 * rtc_time64_to_tm - Converts time64_t to rtc_time.

 * 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)

{

	if (tm->tm_year < 70

		|| ((unsigned)tm->tm_mon) >= 12

		|| tm->tm_mday < 1

		|| tm->tm_mday > rtc_month_days(tm->tm_mon, ((unsigned)tm->tm_year + 1900))

		|| ((unsigned)tm->tm_hour) >= 24

		|| ((unsigned)tm->tm_min) >= 60

		|| ((unsigned)tm->tm_sec) >= 60)

	if (tm->tm_year < 70 ||

	    ((unsigned int)tm->tm_mon) >= 12 ||

	    tm->tm_mday < 1 ||

	    tm->tm_mday > rtc_month_days(tm->tm_mon,

					 ((unsigned int)tm->tm_year + 1900)) ||

	    ((unsigned int)tm->tm_hour) >= 24 ||

	    ((unsigned int)tm->tm_min) >= 60 ||

	    ((unsigned int)tm->tm_sec) >= 60)

		return -EINVAL;



	return 0;
@@ -113,7 +113,7 @@ EXPORT_SYMBOL(rtc_valid_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);

}

EXPORT_SYMBOL(rtc_tm_to_time64);