Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 21ebd93f authored by Linux Build Service Account's avatar Linux Build Service Account Committed by Gerrit - the friendly Code Review server
Browse files

Merge "rtc: alarm: Add power-on alarm feature"

parents 45e8e8dc 1eb7a27d

drivers/rtc/qpnp-rtc.c

+4 −0
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ 
#include <linux/spmi.h>

#include <linux/spinlock.h>

#include <linux/spmi.h>

#include <linux/alarmtimer.h>



/* RTC/ALARM Register offsets */

#define REG_OFFSET_ALARM_RW	0x40
@@ -595,6 +596,9 @@ static int qpnp_rtc_probe(struct spmi_device *spmi) 
		goto fail_rtc_enable;

	}



	/* Init power_on_alarm after adding rtc device */

	power_on_alarm_init();



	/* Request the alarm IRQ */

	rc = request_any_context_irq(rtc_dd->rtc_alarm_irq,

				 qpnp_alarm_trigger, IRQF_TRIGGER_RISING,

fs/timerfd.c

+19 −13
Original line number Diff line number Diff line
@@ -49,7 +49,8 @@ static DEFINE_SPINLOCK(cancel_lock); 
static inline bool isalarm(struct timerfd_ctx *ctx)

{

	return ctx->clockid == CLOCK_REALTIME_ALARM ||

		ctx->clockid == CLOCK_BOOTTIME_ALARM;

		ctx->clockid == CLOCK_BOOTTIME_ALARM ||

		ctx->clockid == CLOCK_POWEROFF_ALARM;

}



/*
@@ -133,7 +134,8 @@ static bool timerfd_canceled(struct timerfd_ctx *ctx) 
static void timerfd_setup_cancel(struct timerfd_ctx *ctx, int flags)

{

	if ((ctx->clockid == CLOCK_REALTIME ||

	     ctx->clockid == CLOCK_REALTIME_ALARM) &&

	     ctx->clockid == CLOCK_REALTIME_ALARM ||

	     ctx->clockid == CLOCK_POWEROFF_ALARM) &&

	    (flags & TFD_TIMER_ABSTIME) && (flags & TFD_TIMER_CANCEL_ON_SET)) {

		if (!ctx->might_cancel) {

			ctx->might_cancel = true;
@@ -164,6 +166,7 @@ static int timerfd_setup(struct timerfd_ctx *ctx, int flags, 
	enum hrtimer_mode htmode;

	ktime_t texp;

	int clockid = ctx->clockid;

	enum alarmtimer_type type;



	htmode = (flags & TFD_TIMER_ABSTIME) ?

		HRTIMER_MODE_ABS: HRTIMER_MODE_REL;
@@ -174,10 +177,8 @@ static int timerfd_setup(struct timerfd_ctx *ctx, int flags, 
	ctx->tintv = timespec_to_ktime(ktmr->it_interval);



	if (isalarm(ctx)) {

		alarm_init(&ctx->t.alarm,

			   ctx->clockid == CLOCK_REALTIME_ALARM ?

			   ALARM_REALTIME : ALARM_BOOTTIME,

			   timerfd_alarmproc);

		type = clock2alarm(ctx->clockid);

		alarm_init(&ctx->t.alarm, type, timerfd_alarmproc);

	} else {

		hrtimer_init(&ctx->t.tmr, clockid, htmode);

		hrtimer_set_expires(&ctx->t.tmr, texp);
@@ -376,6 +377,7 @@ SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags) 
{

	int ufd;

	struct timerfd_ctx *ctx;

	enum alarmtimer_type type;



	/* Check the TFD_* constants for consistency.  */

	BUILD_BUG_ON(TFD_CLOEXEC != O_CLOEXEC);
@@ -386,7 +388,8 @@ SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags) 
	     clockid != CLOCK_REALTIME &&

	     clockid != CLOCK_REALTIME_ALARM &&

	     clockid != CLOCK_BOOTTIME &&

	     clockid != CLOCK_BOOTTIME_ALARM))

	     clockid != CLOCK_BOOTTIME_ALARM &&

	     clockid != CLOCK_POWEROFF_ALARM))

		return -EINVAL;



	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
@@ -396,13 +399,12 @@ SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags) 
	init_waitqueue_head(&ctx->wqh);

	ctx->clockid = clockid;



	if (isalarm(ctx))

		alarm_init(&ctx->t.alarm,

			   ctx->clockid == CLOCK_REALTIME_ALARM ?

			   ALARM_REALTIME : ALARM_BOOTTIME,

			   timerfd_alarmproc);

	else

	if (isalarm(ctx)) {

		type = clock2alarm(ctx->clockid);

		alarm_init(&ctx->t.alarm, type, timerfd_alarmproc);

	} else {

		hrtimer_init(&ctx->t.tmr, clockid, HRTIMER_MODE_ABS);

	}



	ctx->moffs = ktime_mono_to_real((ktime_t){ .tv64 = 0 });
@@ -474,6 +476,10 @@ static int do_timerfd_settime(int ufd, int flags, 
	ret = timerfd_setup(ctx, flags, new);



	spin_unlock_irq(&ctx->wqh.lock);



	if (ctx->clockid == CLOCK_POWEROFF_ALARM)

		set_power_on_alarm();



	fdput(f);

	return ret;

}

include/linux/alarmtimer.h

+5 −0
Original line number Diff line number Diff line
@@ -5,10 +5,12 @@ 
#include <linux/hrtimer.h>

#include <linux/timerqueue.h>

#include <linux/rtc.h>

#include <linux/types.h>



enum alarmtimer_type {

	ALARM_REALTIME,

	ALARM_BOOTTIME,

	ALARM_POWEROFF_REALTIME,



	ALARM_NUMTYPE,

};
@@ -48,6 +50,9 @@ int alarm_start_relative(struct alarm *alarm, ktime_t start); 
void alarm_restart(struct alarm *alarm);

int alarm_try_to_cancel(struct alarm *alarm);

int alarm_cancel(struct alarm *alarm);

void set_power_on_alarm(void);

void power_on_alarm_init(void);

enum alarmtimer_type clock2alarm(clockid_t clockid);



u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval);

u64 alarm_forward_now(struct alarm *alarm, ktime_t interval);

include/uapi/linux/time.h

+1 −0
Original line number Diff line number Diff line
@@ -60,6 +60,7 @@ struct itimerval { 
#define CLOCK_BOOTTIME_ALARM		9

#define CLOCK_SGI_CYCLE			10	/* Hardware specific */

#define CLOCK_TAI			11

#define CLOCK_POWEROFF_ALARM		12



#define MAX_CLOCKS			16

#define CLOCKS_MASK			(CLOCK_REALTIME | CLOCK_MONOTONIC)

kernel/time/alarmtimer.c

+136 −1
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 
#include <linux/workqueue.h>

#include <linux/freezer.h>

#include "lpm-levels.h"

#include <linux/workqueue.h>



/**

 * struct alarm_base - Alarm timer bases
@@ -53,6 +54,115 @@ static struct wakeup_source *ws; 
static struct rtc_timer		rtctimer;

static struct rtc_device	*rtcdev;

static DEFINE_SPINLOCK(rtcdev_lock);

static struct mutex power_on_alarm_lock;

struct delayed_work work;

struct alarm init_alarm;

static struct workqueue_struct *power_off_alarm_workqueue;



/**

 * power_on_alarm_init - Init power on alarm value

 *

 * Read rtc alarm value after device booting up and add this alarm

 * into alarm queue.

 */

void power_on_alarm_init(void)

{

	struct rtc_wkalrm rtc_alarm;

	struct rtc_time rt;

	unsigned long alarm_time;

	struct rtc_device *rtc;

	ktime_t alarm_ktime;



	rtc = alarmtimer_get_rtcdev();



	if (!rtc)

		return;



	rtc_read_alarm(rtc, &rtc_alarm);

	rt = rtc_alarm.time;



	rtc_tm_to_time(&rt, &alarm_time);



	if (alarm_time) {

		alarm_ktime = ktime_set(alarm_time, 0);

		alarm_init(&init_alarm, ALARM_POWEROFF_REALTIME, NULL);

		alarm_start(&init_alarm, alarm_ktime);

	}

}



/**

 * set_power_on_alarm - set power on alarm value into rtc register

 *

 * Get the soonest power off alarm timer and set the alarm value into rtc

 * register.

 */

void set_power_on_alarm(void)

{

	int rc;

	struct timespec wall_time, alarm_ts;

	long alarm_secs = 0l;

	long rtc_secs, alarm_time, alarm_delta;

	struct rtc_time rtc_time;

	struct rtc_wkalrm alarm;

	struct rtc_device *rtc;

	struct timerqueue_node *next;

	unsigned long flags;

	struct alarm_base *base = &alarm_bases[ALARM_POWEROFF_REALTIME];



	rc = mutex_lock_interruptible(&power_on_alarm_lock);

	if (rc != 0)

		return;



	spin_lock_irqsave(&base->lock, flags);

	next = timerqueue_getnext(&base->timerqueue);

	spin_unlock_irqrestore(&base->lock, flags);



	if (next) {

		alarm_ts = ktime_to_timespec(next->expires);

		alarm_secs = alarm_ts.tv_sec;

	}



	if (!alarm_secs)

		goto disable_alarm;



	getnstimeofday(&wall_time);



	/*

	  alarm_secs have to be bigger than "wall_time +1".

	  It is to make sure that alarm time will be always

	  bigger than wall time.

	*/

	if (alarm_secs <= wall_time.tv_sec + 1)

		goto disable_alarm;



	rtc = alarmtimer_get_rtcdev();

	if (!rtc)

		goto exit;



	rtc_read_time(rtc, &rtc_time);

	rtc_tm_to_time(&rtc_time, &rtc_secs);

	alarm_delta = wall_time.tv_sec - rtc_secs;

	alarm_time = alarm_secs - alarm_delta;



	rtc_time_to_tm(alarm_time, &alarm.time);

	alarm.enabled = 1;

	rc = rtc_set_alarm(rtcdev, &alarm);

	if (rc)

		goto disable_alarm;



	mutex_unlock(&power_on_alarm_lock);

	return;



disable_alarm:

	rtc_alarm_irq_enable(rtcdev, 0);

exit:

	mutex_unlock(&power_on_alarm_lock);

}



static void alarm_work_func(struct work_struct *unused)

{

	set_power_on_alarm();

}



static void alarmtimer_triggered_func(void *p)

{
@@ -124,6 +234,8 @@ static void alarmtimer_rtc_remove_device(struct device *dev, 


static inline void alarmtimer_rtc_timer_init(void)

{

	mutex_init(&power_on_alarm_lock);



	rtc_timer_init(&rtctimer, NULL, NULL);

}
@@ -221,6 +333,10 @@ static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer) 
	}

	spin_unlock_irqrestore(&base->lock, flags);



	/* set next power off alarm */

	if (alarm->type == ALARM_POWEROFF_REALTIME)

		queue_delayed_work(power_off_alarm_workqueue, &work, 0);



	return ret;



}
@@ -253,6 +369,8 @@ static int alarmtimer_suspend(struct device *dev) 
	int i;

	int ret = 0;



	cancel_delayed_work_sync(&work);



	spin_lock_irqsave(&freezer_delta_lock, flags);

	min = freezer_delta;

	freezer_delta = ktime_set(0, 0);
@@ -316,6 +434,8 @@ static int alarmtimer_suspend(struct device *dev) 
	int i;

	int ret;



	cancel_delayed_work_sync(&work);



	spin_lock_irqsave(&freezer_delta_lock, flags);

	min = freezer_delta;

	freezer_delta = ktime_set(0, 0);
@@ -371,8 +491,11 @@ static int alarmtimer_resume(struct device *dev) 
	if (!rtc)

		return 0;

	rtc_timer_cancel(rtc, &rtctimer);



	queue_delayed_work(power_off_alarm_workqueue, &work, 0);

	return 0;

}



#else

static int alarmtimer_suspend(struct device *dev)

{
@@ -553,12 +676,14 @@ EXPORT_SYMBOL_GPL(alarm_forward_now); 
 * clock2alarm - helper that converts from clockid to alarmtypes

 * @clockid: clockid.

 */

static enum alarmtimer_type clock2alarm(clockid_t clockid)

enum alarmtimer_type clock2alarm(clockid_t clockid)

{

	if (clockid == CLOCK_REALTIME_ALARM)

		return ALARM_REALTIME;

	if (clockid == CLOCK_BOOTTIME_ALARM)

		return ALARM_BOOTTIME;

	if (clockid == CLOCK_POWEROFF_ALARM)

		return ALARM_POWEROFF_REALTIME;

	return -1;

}
@@ -945,10 +1070,13 @@ static int __init alarmtimer_init(void) 


	posix_timers_register_clock(CLOCK_REALTIME_ALARM, &alarm_clock);

	posix_timers_register_clock(CLOCK_BOOTTIME_ALARM, &alarm_clock);

	posix_timers_register_clock(CLOCK_POWEROFF_ALARM, &alarm_clock);



	/* Initialize alarm bases */

	alarm_bases[ALARM_REALTIME].base_clockid = CLOCK_REALTIME;

	alarm_bases[ALARM_REALTIME].gettime = &ktime_get_real;

	alarm_bases[ALARM_POWEROFF_REALTIME].base_clockid = CLOCK_REALTIME;

	alarm_bases[ALARM_POWEROFF_REALTIME].gettime = &ktime_get_real;

	alarm_bases[ALARM_BOOTTIME].base_clockid = CLOCK_BOOTTIME;

	alarm_bases[ALARM_BOOTTIME].gettime = &ktime_get_boottime;

	for (i = 0; i < ALARM_NUMTYPE; i++) {
@@ -970,6 +1098,13 @@ static int __init alarmtimer_init(void) 
		goto out_drv;

	}

	ws = wakeup_source_register("alarmtimer");



	INIT_DELAYED_WORK(&work, alarm_work_func);

	power_off_alarm_workqueue =

		create_singlethread_workqueue("power_off_alarm");

	if (!power_off_alarm_workqueue)

		return -ENOMEM;



	return 0;



out_drv: