[linux-block.git] / drivers / rtc / rtc-cros-ec.c

// SPDX-License-Identifier: GPL-2.0
// RTC driver for ChromeOS Embedded Controller.
//
// Copyright (C) 2017 Google, Inc.
// Author: Stephen Barber <smbarber@chromium.org>

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_data/cros_ec_commands.h>
#include <linux/platform_data/cros_ec_proto.h>
#include <linux/platform_device.h>
#include <linux/rtc.h>
#include <linux/slab.h>

#define DRV_NAME	"cros-ec-rtc"

#define SECS_PER_DAY	(24 * 60 * 60)

/**
 * struct cros_ec_rtc - Driver data for EC RTC
 *
 * @cros_ec: Pointer to EC device
 * @rtc: Pointer to RTC device
 * @notifier: Notifier info for responding to EC events
 * @saved_alarm: Alarm to restore when interrupts are reenabled
 */
struct cros_ec_rtc {
	struct cros_ec_device *cros_ec;
	struct rtc_device *rtc;
	struct notifier_block notifier;
	u32 saved_alarm;
};

static int cros_ec_rtc_get(struct cros_ec_device *cros_ec, u32 command,
			   u32 *response)
{
	int ret;
	struct {
		struct cros_ec_command msg;
		struct ec_response_rtc data;
	} __packed msg;

	memset(&msg, 0, sizeof(msg));
	msg.msg.command = command;
	msg.msg.insize = sizeof(msg.data);

	ret = cros_ec_cmd_xfer_status(cros_ec, &msg.msg);
	if (ret < 0)
		return ret;

	*response = msg.data.time;

	return 0;
}

static int cros_ec_rtc_set(struct cros_ec_device *cros_ec, u32 command,
			   u32 param)
{
	int ret;
	struct {
		struct cros_ec_command msg;
		struct ec_response_rtc data;
	} __packed msg;

	memset(&msg, 0, sizeof(msg));
	msg.msg.command = command;
	msg.msg.outsize = sizeof(msg.data);
	msg.data.time = param;

	ret = cros_ec_cmd_xfer_status(cros_ec, &msg.msg);
	if (ret < 0)
		return ret;
	return 0;
}

/* Read the current time from the EC. */
static int cros_ec_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
	struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
	int ret;
	u32 time;

	ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_VALUE, &time);
	if (ret) {
		dev_err(dev, "error getting time: %d\n", ret);
		return ret;
	}

	rtc_time64_to_tm(time, tm);

	return 0;
}

/* Set the current EC time. */
static int cros_ec_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
	struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
	int ret;
	time64_t time = rtc_tm_to_time64(tm);

	ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_VALUE, (u32)time);
	if (ret < 0) {
		dev_err(dev, "error setting time: %d\n", ret);
		return ret;
	}

	return 0;
}

/* Read alarm time from RTC. */
static int cros_ec_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
	struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
	int ret;
	u32 current_time, alarm_offset;

	/*
	 * The EC host command for getting the alarm is relative (i.e. 5
	 * seconds from now) whereas rtc_wkalrm is absolute. Get the current
	 * RTC time first so we can calculate the relative time.
	 */
	ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_VALUE, &current_time);
	if (ret < 0) {
		dev_err(dev, "error getting time: %d\n", ret);
		return ret;
	}

	ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_ALARM, &alarm_offset);
	if (ret < 0) {
		dev_err(dev, "error getting alarm: %d\n", ret);
		return ret;
	}

	rtc_time64_to_tm(current_time + alarm_offset, &alrm->time);

	return 0;
}

/* Set the EC's RTC alarm. */
static int cros_ec_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
	struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
	int ret;
	time64_t alarm_time;
	u32 current_time, alarm_offset;

	/*
	 * The EC host command for setting the alarm is relative
	 * (i.e. 5 seconds from now) whereas rtc_wkalrm is absolute.
	 * Get the current RTC time first so we can calculate the
	 * relative time.
	 */
	ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_VALUE, &current_time);
	if (ret < 0) {
		dev_err(dev, "error getting time: %d\n", ret);
		return ret;
	}

	alarm_time = rtc_tm_to_time64(&alrm->time);

	if (alarm_time < 0 || alarm_time > U32_MAX)
		return -EINVAL;

	if (!alrm->enabled) {
		/*
		 * If the alarm is being disabled, send an alarm
		 * clear command.
		 */
		alarm_offset = EC_RTC_ALARM_CLEAR;
		cros_ec_rtc->saved_alarm = (u32)alarm_time;
	} else {
		/* Don't set an alarm in the past. */
		if ((u32)alarm_time <= current_time)
			return -ETIME;

		alarm_offset = (u32)alarm_time - current_time;
	}

	ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM, alarm_offset);
	if (ret < 0) {
		if (ret == -EINVAL && alarm_offset >= SECS_PER_DAY) {
			/*
			 * RTC chips on some older Chromebooks can only handle
			 * alarms up to 24h in the future. Try to set an alarm
			 * below that limit to avoid suspend failures.
			 */
			ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM,
					      SECS_PER_DAY - 1);
		}

		if (ret < 0) {
			dev_err(dev, "error setting alarm in %u seconds: %d\n",
				alarm_offset, ret);
			return ret;
		}
	}

	return 0;
}

static int cros_ec_rtc_alarm_irq_enable(struct device *dev,
					unsigned int enabled)
{
	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
	struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
	int ret;
	u32 current_time, alarm_offset, alarm_value;

	ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_VALUE, &current_time);
	if (ret < 0) {
		dev_err(dev, "error getting time: %d\n", ret);
		return ret;
	}

	if (enabled) {
		/* Restore saved alarm if it's still in the future. */
		if (cros_ec_rtc->saved_alarm < current_time)
			alarm_offset = EC_RTC_ALARM_CLEAR;
		else
			alarm_offset = cros_ec_rtc->saved_alarm - current_time;

		ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM,
				      alarm_offset);
		if (ret < 0) {
			dev_err(dev, "error restoring alarm: %d\n", ret);
			return ret;
		}
	} else {
		/* Disable alarm, saving the old alarm value. */
		ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_ALARM,
				      &alarm_offset);
		if (ret < 0) {
			dev_err(dev, "error saving alarm: %d\n", ret);
			return ret;
		}

		alarm_value = current_time + alarm_offset;

		/*
		 * If the current EC alarm is already past, we don't want
		 * to set an alarm when we go through the alarm irq enable
		 * path.
		 */
		if (alarm_value < current_time)
			cros_ec_rtc->saved_alarm = EC_RTC_ALARM_CLEAR;
		else
			cros_ec_rtc->saved_alarm = alarm_value;

		alarm_offset = EC_RTC_ALARM_CLEAR;
		ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM,
				      alarm_offset);
		if (ret < 0) {
			dev_err(dev, "error disabling alarm: %d\n", ret);
			return ret;
		}
	}

	return 0;
}

static int cros_ec_rtc_event(struct notifier_block *nb,
			     unsigned long queued_during_suspend,
			     void *_notify)
{
	struct cros_ec_rtc *cros_ec_rtc;
	struct rtc_device *rtc;
	struct cros_ec_device *cros_ec;
	u32 host_event;

	cros_ec_rtc = container_of(nb, struct cros_ec_rtc, notifier);
	rtc = cros_ec_rtc->rtc;
	cros_ec = cros_ec_rtc->cros_ec;

	host_event = cros_ec_get_host_event(cros_ec);
	if (host_event & EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC)) {
		rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF);
		return NOTIFY_OK;
	} else {
		return NOTIFY_DONE;
	}
}

static const struct rtc_class_ops cros_ec_rtc_ops = {
	.read_time = cros_ec_rtc_read_time,
	.set_time = cros_ec_rtc_set_time,
	.read_alarm = cros_ec_rtc_read_alarm,
	.set_alarm = cros_ec_rtc_set_alarm,
	.alarm_irq_enable = cros_ec_rtc_alarm_irq_enable,
};

#ifdef CONFIG_PM_SLEEP
static int cros_ec_rtc_suspend(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev);

	if (device_may_wakeup(dev))
		return enable_irq_wake(cros_ec_rtc->cros_ec->irq);

	return 0;
}

static int cros_ec_rtc_resume(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev);

	if (device_may_wakeup(dev))
		return disable_irq_wake(cros_ec_rtc->cros_ec->irq);

	return 0;
}
#endif

static SIMPLE_DEV_PM_OPS(cros_ec_rtc_pm_ops, cros_ec_rtc_suspend,
			 cros_ec_rtc_resume);

static int cros_ec_rtc_probe(struct platform_device *pdev)
{
	struct cros_ec_dev *ec_dev = dev_get_drvdata(pdev->dev.parent);
	struct cros_ec_device *cros_ec = ec_dev->ec_dev;
	struct cros_ec_rtc *cros_ec_rtc;
	struct rtc_time tm;
	int ret;

	cros_ec_rtc = devm_kzalloc(&pdev->dev, sizeof(*cros_ec_rtc),
				   GFP_KERNEL);
	if (!cros_ec_rtc)
		return -ENOMEM;

	platform_set_drvdata(pdev, cros_ec_rtc);
	cros_ec_rtc->cros_ec = cros_ec;

	/* Get initial time */
	ret = cros_ec_rtc_read_time(&pdev->dev, &tm);
	if (ret) {
		dev_err(&pdev->dev, "failed to read RTC time\n");
		return ret;
	}

	ret = device_init_wakeup(&pdev->dev, 1);
	if (ret) {
		dev_err(&pdev->dev, "failed to initialize wakeup\n");
		return ret;
	}

	cros_ec_rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
	if (IS_ERR(cros_ec_rtc->rtc))
		return PTR_ERR(cros_ec_rtc->rtc);

	cros_ec_rtc->rtc->ops = &cros_ec_rtc_ops;
	cros_ec_rtc->rtc->range_max = U32_MAX;

	ret = devm_rtc_register_device(cros_ec_rtc->rtc);
	if (ret)
		return ret;

	/* Get RTC events from the EC. */
	cros_ec_rtc->notifier.notifier_call = cros_ec_rtc_event;
	ret = blocking_notifier_chain_register(&cros_ec->event_notifier,
					       &cros_ec_rtc->notifier);
	if (ret) {
		dev_err(&pdev->dev, "failed to register notifier\n");
		return ret;
	}

	return 0;
}

static void cros_ec_rtc_remove(struct platform_device *pdev)
{
	struct cros_ec_rtc *cros_ec_rtc = platform_get_drvdata(pdev);
	struct device *dev = &pdev->dev;
	int ret;

	ret = blocking_notifier_chain_unregister(
				&cros_ec_rtc->cros_ec->event_notifier,
				&cros_ec_rtc->notifier);
	if (ret)
		dev_err(dev, "failed to unregister notifier\n");
}

static struct platform_driver cros_ec_rtc_driver = {
	.probe = cros_ec_rtc_probe,
	.remove_new = cros_ec_rtc_remove,
	.driver = {
		.name = DRV_NAME,
		.pm = &cros_ec_rtc_pm_ops,
	},
};

module_platform_driver(cros_ec_rtc_driver);

MODULE_DESCRIPTION("RTC driver for Chrome OS ECs");
MODULE_AUTHOR("Stephen Barber <smbarber@chromium.org>");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:" DRV_NAME);
Commit	Line	Data
8ee4aee5 EBS	1	// SPDX-License-Identifier: GPL-2.0
	2	// RTC driver for ChromeOS Embedded Controller.
	3	//
	4	// Copyright (C) 2017 Google, Inc.
	5	// Author: Stephen Barber <smbarber@chromium.org>
6f2a71a3 SB	6
6f2a71a3 SB	7	#include <linux/kernel.h>
6f2a71a3	8	#include <linux/module.h>
840d9f13 EBS	9	#include <linux/platform_data/cros_ec_commands.h>
840d9f13 EBS	10	#include <linux/platform_data/cros_ec_proto.h>
6f2a71a3 SB	11	#include <linux/platform_device.h>
	12	#include <linux/rtc.h>
	13	#include <linux/slab.h>
	14
	15	#define DRV_NAME "cros-ec-rtc"
	16
f27efee6 GR	17	#define SECS_PER_DAY (24 * 60 * 60)
f27efee6 GR	18
6f2a71a3 SB	19	/**
	20	* struct cros_ec_rtc - Driver data for EC RTC
	21	*
	22	* @cros_ec: Pointer to EC device
	23	* @rtc: Pointer to RTC device
	24	* @notifier: Notifier info for responding to EC events
	25	* @saved_alarm: Alarm to restore when interrupts are reenabled
	26	*/
	27	struct cros_ec_rtc {
	28	struct cros_ec_device *cros_ec;
	29	struct rtc_device *rtc;
	30	struct notifier_block notifier;
	31	u32 saved_alarm;
	32	};
	33
	34	static int cros_ec_rtc_get(struct cros_ec_device *cros_ec, u32 command,
	35	u32 *response)
	36	{
	37	int ret;
	38	struct {
	39	struct cros_ec_command msg;
	40	struct ec_response_rtc data;
	41	} __packed msg;
	42
	43	memset(&msg, 0, sizeof(msg));
	44	msg.msg.command = command;
	45	msg.msg.insize = sizeof(msg.data);
	46
	47	ret = cros_ec_cmd_xfer_status(cros_ec, &msg.msg);
f27efee6	48	if (ret < 0)
6f2a71a3	49	return ret;
6f2a71a3 SB	50
	51	*response = msg.data.time;
	52
	53	return 0;
	54	}
	55
	56	static int cros_ec_rtc_set(struct cros_ec_device *cros_ec, u32 command,
	57	u32 param)
	58	{
f27efee6	59	int ret;
6f2a71a3 SB	60	struct {
	61	struct cros_ec_command msg;
	62	struct ec_response_rtc data;
	63	} __packed msg;
	64
	65	memset(&msg, 0, sizeof(msg));
	66	msg.msg.command = command;
	67	msg.msg.outsize = sizeof(msg.data);
	68	msg.data.time = param;
	69
	70	ret = cros_ec_cmd_xfer_status(cros_ec, &msg.msg);
f27efee6	71	if (ret < 0)
6f2a71a3	72	return ret;
6f2a71a3 SB	73	return 0;
	74	}
	75
	76	/* Read the current time from the EC. */
	77	static int cros_ec_rtc_read_time(struct device dev, struct rtc_time tm)
	78	{
	79	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
	80	struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
	81	int ret;
	82	u32 time;
	83
	84	ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_VALUE, &time);
	85	if (ret) {
	86	dev_err(dev, "error getting time: %d\n", ret);
	87	return ret;
	88	}
	89
	90	rtc_time64_to_tm(time, tm);
	91
	92	return 0;
	93	}
	94
	95	/* Set the current EC time. */
	96	static int cros_ec_rtc_set_time(struct device dev, struct rtc_time tm)
	97	{
	98	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
	99	struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
	100	int ret;
0e843137	101	time64_t time = rtc_tm_to_time64(tm);
6f2a71a3 SB	102
	103	ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_VALUE, (u32)time);
	104	if (ret < 0) {
	105	dev_err(dev, "error setting time: %d\n", ret);
	106	return ret;
	107	}
	108
	109	return 0;
	110	}
	111
	112	/* Read alarm time from RTC. */
	113	static int cros_ec_rtc_read_alarm(struct device dev, struct rtc_wkalrm alrm)
	114	{
	115	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
	116	struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
	117	int ret;
	118	u32 current_time, alarm_offset;
	119
	120	/*
	121	* The EC host command for getting the alarm is relative (i.e. 5
	122	* seconds from now) whereas rtc_wkalrm is absolute. Get the current
	123	* RTC time first so we can calculate the relative time.
	124	*/
	125	ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_VALUE, &current_time);
	126	if (ret < 0) {
	127	dev_err(dev, "error getting time: %d\n", ret);
	128	return ret;
	129	}
	130
	131	ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_ALARM, &alarm_offset);
	132	if (ret < 0) {
	133	dev_err(dev, "error getting alarm: %d\n", ret);
	134	return ret;
	135	}
	136
	137	rtc_time64_to_tm(current_time + alarm_offset, &alrm->time);
	138
	139	return 0;
	140	}
	141
	142	/* Set the EC's RTC alarm. */
	143	static int cros_ec_rtc_set_alarm(struct device dev, struct rtc_wkalrm alrm)
	144	{
	145	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
	146	struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
	147	int ret;
	148	time64_t alarm_time;
	149	u32 current_time, alarm_offset;
	150
	151	/*
	152	* The EC host command for setting the alarm is relative
	153	* (i.e. 5 seconds from now) whereas rtc_wkalrm is absolute.
	154	* Get the current RTC time first so we can calculate the
	155	* relative time.
	156	*/
	157	ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_VALUE, &current_time);
	158	if (ret < 0) {
	159	dev_err(dev, "error getting time: %d\n", ret);
	160	return ret;
	161	}
	162
	163	alarm_time = rtc_tm_to_time64(&alrm->time);
	164
	165	if (alarm_time < 0 \|\| alarm_time > U32_MAX)
166	return -EINVAL;
167
168	if (!alrm->enabled) {
169	/*
170	* If the alarm is being disabled, send an alarm
171	* clear command.
172	*/
173	alarm_offset = EC_RTC_ALARM_CLEAR;
174	cros_ec_rtc->saved_alarm = (u32)alarm_time;
175	} else {
176	/* Don't set an alarm in the past. */
72dd71f0 JC	177	if ((u32)alarm_time <= current_time)
	178	return -ETIME;
	179
	180	alarm_offset = (u32)alarm_time - current_time;
6f2a71a3 SB	181	}
	182
	183	ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM, alarm_offset);
	184	if (ret < 0) {
f27efee6 GR	185	if (ret == -EINVAL && alarm_offset >= SECS_PER_DAY) {
	186	/*
	187	* RTC chips on some older Chromebooks can only handle
	188	* alarms up to 24h in the future. Try to set an alarm
	189	* below that limit to avoid suspend failures.
	190	*/
	191	ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM,
	192	SECS_PER_DAY - 1);
	193	}
	194
	195	if (ret < 0) {
	196	dev_err(dev, "error setting alarm in %u seconds: %d\n",
	197	alarm_offset, ret);
	198	return ret;
	199	}
6f2a71a3 SB	200	}
	201
	202	return 0;
	203	}
	204
	205	static int cros_ec_rtc_alarm_irq_enable(struct device *dev,
	206	unsigned int enabled)
	207	{
	208	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
	209	struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
	210	int ret;
	211	u32 current_time, alarm_offset, alarm_value;
	212
	213	ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_VALUE, &current_time);
	214	if (ret < 0) {
	215	dev_err(dev, "error getting time: %d\n", ret);
	216	return ret;
	217	}
	218
	219	if (enabled) {
	220	/* Restore saved alarm if it's still in the future. */
	221	if (cros_ec_rtc->saved_alarm < current_time)
	222	alarm_offset = EC_RTC_ALARM_CLEAR;
	223	else
	224	alarm_offset = cros_ec_rtc->saved_alarm - current_time;
	225
	226	ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM,
	227	alarm_offset);
	228	if (ret < 0) {
	229	dev_err(dev, "error restoring alarm: %d\n", ret);
	230	return ret;
	231	}
	232	} else {
	233	/* Disable alarm, saving the old alarm value. */
	234	ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_ALARM,
	235	&alarm_offset);
	236	if (ret < 0) {
	237	dev_err(dev, "error saving alarm: %d\n", ret);
	238	return ret;
	239	}
	240
	241	alarm_value = current_time + alarm_offset;
	242
	243	/*
	244	* If the current EC alarm is already past, we don't want
	245	* to set an alarm when we go through the alarm irq enable
	246	* path.
	247	*/
	248	if (alarm_value < current_time)
	249	cros_ec_rtc->saved_alarm = EC_RTC_ALARM_CLEAR;
	250	else
	251	cros_ec_rtc->saved_alarm = alarm_value;
	252
	253	alarm_offset = EC_RTC_ALARM_CLEAR;
	254	ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM,
	255	alarm_offset);
	256	if (ret < 0) {
	257	dev_err(dev, "error disabling alarm: %d\n", ret);
	258	return ret;
	259	}
	260	}
	261
	262	return 0;
	263	}
264
265	static int cros_ec_rtc_event(struct notifier_block *nb,
266	unsigned long queued_during_suspend,
267	void *_notify)
268	{
269	struct cros_ec_rtc *cros_ec_rtc;
270	struct rtc_device *rtc;
271	struct cros_ec_device *cros_ec;
272	u32 host_event;
273
274	cros_ec_rtc = container_of(nb, struct cros_ec_rtc, notifier);
275	rtc = cros_ec_rtc->rtc;
276	cros_ec = cros_ec_rtc->cros_ec;
277
278	host_event = cros_ec_get_host_event(cros_ec);
279	if (host_event & EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC)) {
280	rtc_update_irq(rtc, 1, RTC_IRQF \| RTC_AF);
281	return NOTIFY_OK;
282	} else {
283	return NOTIFY_DONE;
284	}
285	}
286
287	static const struct rtc_class_ops cros_ec_rtc_ops = {
288	.read_time = cros_ec_rtc_read_time,
289	.set_time = cros_ec_rtc_set_time,
290	.read_alarm = cros_ec_rtc_read_alarm,
291	.set_alarm = cros_ec_rtc_set_alarm,
292	.alarm_irq_enable = cros_ec_rtc_alarm_irq_enable,
293	};
294
295	#ifdef CONFIG_PM_SLEEP
296	static int cros_ec_rtc_suspend(struct device *dev)
297	{
298	struct platform_device *pdev = to_platform_device(dev);
299	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev);
300
301	if (device_may_wakeup(dev))
d6752e18	302	return enable_irq_wake(cros_ec_rtc->cros_ec->irq);
6f2a71a3 SB	303
	304	return 0;
	305	}
	306
	307	static int cros_ec_rtc_resume(struct device *dev)
	308	{
	309	struct platform_device *pdev = to_platform_device(dev);
	310	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev);
	311
	312	if (device_may_wakeup(dev))
d6752e18	313	return disable_irq_wake(cros_ec_rtc->cros_ec->irq);
6f2a71a3 SB	314
	315	return 0;
	316	}
	317	#endif
	318
	319	static SIMPLE_DEV_PM_OPS(cros_ec_rtc_pm_ops, cros_ec_rtc_suspend,
	320	cros_ec_rtc_resume);
	321
	322	static int cros_ec_rtc_probe(struct platform_device *pdev)
	323	{
	324	struct cros_ec_dev *ec_dev = dev_get_drvdata(pdev->dev.parent);
	325	struct cros_ec_device *cros_ec = ec_dev->ec_dev;
	326	struct cros_ec_rtc *cros_ec_rtc;
	327	struct rtc_time tm;
	328	int ret;
	329
	330	cros_ec_rtc = devm_kzalloc(&pdev->dev, sizeof(*cros_ec_rtc),
	331	GFP_KERNEL);
	332	if (!cros_ec_rtc)
	333	return -ENOMEM;
	334
	335	platform_set_drvdata(pdev, cros_ec_rtc);
	336	cros_ec_rtc->cros_ec = cros_ec;
	337
	338	/* Get initial time */
	339	ret = cros_ec_rtc_read_time(&pdev->dev, &tm);
	340	if (ret) {
	341	dev_err(&pdev->dev, "failed to read RTC time\n");
	342	return ret;
	343	}
	344
	345	ret = device_init_wakeup(&pdev->dev, 1);
	346	if (ret) {
	347	dev_err(&pdev->dev, "failed to initialize wakeup\n");
	348	return ret;
	349	}
	350
0e843137	351	cros_ec_rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
4fc0d13f AB	352	if (IS_ERR(cros_ec_rtc->rtc))
4fc0d13f AB	353	return PTR_ERR(cros_ec_rtc->rtc);
6f2a71a3	354
0e843137 AB	355	cros_ec_rtc->rtc->ops = &cros_ec_rtc_ops;
	356	cros_ec_rtc->rtc->range_max = U32_MAX;
	357
fdcfd854	358	ret = devm_rtc_register_device(cros_ec_rtc->rtc);
0e843137 AB	359	if (ret)
	360	return ret;
	361
6f2a71a3 SB	362	/* Get RTC events from the EC. */
	363	cros_ec_rtc->notifier.notifier_call = cros_ec_rtc_event;
	364	ret = blocking_notifier_chain_register(&cros_ec->event_notifier,
	365	&cros_ec_rtc->notifier);
	366	if (ret) {
	367	dev_err(&pdev->dev, "failed to register notifier\n");
	368	return ret;
	369	}
	370
	371	return 0;
	372	}
	373
0d8742e6	374	static void cros_ec_rtc_remove(struct platform_device *pdev)
6f2a71a3 SB	375	{
	376	struct cros_ec_rtc *cros_ec_rtc = platform_get_drvdata(pdev);
	377	struct device *dev = &pdev->dev;
	378	int ret;
	379
	380	ret = blocking_notifier_chain_unregister(
	381	&cros_ec_rtc->cros_ec->event_notifier,
	382	&cros_ec_rtc->notifier);
5c9f4144	383	if (ret)
6f2a71a3	384	dev_err(dev, "failed to unregister notifier\n");
6f2a71a3 SB	385	}
	386
	387	static struct platform_driver cros_ec_rtc_driver = {
	388	.probe = cros_ec_rtc_probe,
0d8742e6	389	.remove_new = cros_ec_rtc_remove,
6f2a71a3 SB	390	.driver = {
	391	.name = DRV_NAME,
	392	.pm = &cros_ec_rtc_pm_ops,
	393	},
	394	};
	395
	396	module_platform_driver(cros_ec_rtc_driver);
	397
	398	MODULE_DESCRIPTION("RTC driver for Chrome OS ECs");
	399	MODULE_AUTHOR("Stephen Barber <smbarber@chromium.org>");
e6988d23	400	MODULE_LICENSE("GPL v2");
6f2a71a3	401	MODULE_ALIAS("platform:" DRV_NAME);