[linux-2.6-block.git] / drivers / rtc / rtc-mrst.c

/*
 * rtc-mrst.c: Driver for Moorestown virtual RTC
 *
 * (C) Copyright 2009 Intel Corporation
 * Author: Jacob Pan (jacob.jun.pan@intel.com)
 *	   Feng Tang (feng.tang@intel.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; version 2
 * of the License.
 *
 * Note:
 * VRTC is emulated by system controller firmware, the real HW
 * RTC is located in the PMIC device. SCU FW shadows PMIC RTC
 * in a memory mapped IO space that is visible to the host IA
 * processor.
 *
 * This driver is based upon drivers/rtc/rtc-cmos.c
 */

/*
 * Note:
 *  * vRTC only supports binary mode and 24H mode
 *  * vRTC only support PIE and AIE, no UIE, and its PIE only happens
 *    at 23:59:59pm everyday, no support for adjustable frequency
 *  * Alarm function is also limited to hr/min/sec.
 */

#include <linux/mod_devicetable.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/kernel.h>
#include <linux/mc146818rtc.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sfi.h>

#include <asm/intel_scu_ipc.h>
#include <asm/intel-mid.h>
#include <asm/intel_mid_vrtc.h>

struct mrst_rtc {
	struct rtc_device	*rtc;
	struct device		*dev;
	int			irq;

	u8			enabled_wake;
	u8			suspend_ctrl;
};

static const char driver_name[] = "rtc_mrst";

#define	RTC_IRQMASK	(RTC_PF | RTC_AF)

static inline int is_intr(u8 rtc_intr)
{
	if (!(rtc_intr & RTC_IRQF))
		return 0;
	return rtc_intr & RTC_IRQMASK;
}

static inline unsigned char vrtc_is_updating(void)
{
	unsigned char uip;
	unsigned long flags;

	spin_lock_irqsave(&rtc_lock, flags);
	uip = (vrtc_cmos_read(RTC_FREQ_SELECT) & RTC_UIP);
	spin_unlock_irqrestore(&rtc_lock, flags);
	return uip;
}

/*
 * rtc_time's year contains the increment over 1900, but vRTC's YEAR
 * register can't be programmed to value larger than 0x64, so vRTC
 * driver chose to use 1972 (1970 is UNIX time start point) as the base,
 * and does the translation at read/write time.
 *
 * Why not just use 1970 as the offset? it's because using 1972 will
 * make it consistent in leap year setting for both vrtc and low-level
 * physical rtc devices. Then why not use 1960 as the offset? If we use
 * 1960, for a device's first use, its YEAR register is 0 and the system
 * year will be parsed as 1960 which is not a valid UNIX time and will
 * cause many applications to fail mysteriously.
 */
static int mrst_read_time(struct device *dev, struct rtc_time *time)
{
	unsigned long flags;

	if (vrtc_is_updating())
		msleep(20);

	spin_lock_irqsave(&rtc_lock, flags);
	time->tm_sec = vrtc_cmos_read(RTC_SECONDS);
	time->tm_min = vrtc_cmos_read(RTC_MINUTES);
	time->tm_hour = vrtc_cmos_read(RTC_HOURS);
	time->tm_mday = vrtc_cmos_read(RTC_DAY_OF_MONTH);
	time->tm_mon = vrtc_cmos_read(RTC_MONTH);
	time->tm_year = vrtc_cmos_read(RTC_YEAR);
	spin_unlock_irqrestore(&rtc_lock, flags);

	/* Adjust for the 1972/1900 */
	time->tm_year += 72;
	time->tm_mon--;
	return 0;
}

static int mrst_set_time(struct device *dev, struct rtc_time *time)
{
	int ret;
	unsigned long flags;
	unsigned char mon, day, hrs, min, sec;
	unsigned int yrs;

	yrs = time->tm_year;
	mon = time->tm_mon + 1;   /* tm_mon starts at zero */
	day = time->tm_mday;
	hrs = time->tm_hour;
	min = time->tm_min;
	sec = time->tm_sec;

	if (yrs < 72 || yrs > 172)
		return -EINVAL;
	yrs -= 72;

	spin_lock_irqsave(&rtc_lock, flags);

	vrtc_cmos_write(yrs, RTC_YEAR);
	vrtc_cmos_write(mon, RTC_MONTH);
	vrtc_cmos_write(day, RTC_DAY_OF_MONTH);
	vrtc_cmos_write(hrs, RTC_HOURS);
	vrtc_cmos_write(min, RTC_MINUTES);
	vrtc_cmos_write(sec, RTC_SECONDS);

	spin_unlock_irqrestore(&rtc_lock, flags);

	ret = intel_scu_ipc_simple_command(IPCMSG_VRTC, IPC_CMD_VRTC_SETTIME);
	return ret;
}

static int mrst_read_alarm(struct device *dev, struct rtc_wkalrm *t)
{
	struct mrst_rtc	*mrst = dev_get_drvdata(dev);
	unsigned char rtc_control;

	if (mrst->irq <= 0)
		return -EIO;

	/* vRTC only supports binary mode */
	spin_lock_irq(&rtc_lock);
	t->time.tm_sec = vrtc_cmos_read(RTC_SECONDS_ALARM);
	t->time.tm_min = vrtc_cmos_read(RTC_MINUTES_ALARM);
	t->time.tm_hour = vrtc_cmos_read(RTC_HOURS_ALARM);

	rtc_control = vrtc_cmos_read(RTC_CONTROL);
	spin_unlock_irq(&rtc_lock);

	t->enabled = !!(rtc_control & RTC_AIE);
	t->pending = 0;

	return 0;
}

static void mrst_checkintr(struct mrst_rtc *mrst, unsigned char rtc_control)
{
	unsigned char	rtc_intr;

	/*
	 * NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
	 * allegedly some older rtcs need that to handle irqs properly
	 */
	rtc_intr = vrtc_cmos_read(RTC_INTR_FLAGS);
	rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
	if (is_intr(rtc_intr))
		rtc_update_irq(mrst->rtc, 1, rtc_intr);
}

static void mrst_irq_enable(struct mrst_rtc *mrst, unsigned char mask)
{
	unsigned char	rtc_control;

	/*
	 * Flush any pending IRQ status, notably for update irqs,
	 * before we enable new IRQs
	 */
	rtc_control = vrtc_cmos_read(RTC_CONTROL);
	mrst_checkintr(mrst, rtc_control);

	rtc_control |= mask;
	vrtc_cmos_write(rtc_control, RTC_CONTROL);

	mrst_checkintr(mrst, rtc_control);
}

static void mrst_irq_disable(struct mrst_rtc *mrst, unsigned char mask)
{
	unsigned char	rtc_control;

	rtc_control = vrtc_cmos_read(RTC_CONTROL);
	rtc_control &= ~mask;
	vrtc_cmos_write(rtc_control, RTC_CONTROL);
	mrst_checkintr(mrst, rtc_control);
}

static int mrst_set_alarm(struct device *dev, struct rtc_wkalrm *t)
{
	struct mrst_rtc	*mrst = dev_get_drvdata(dev);
	unsigned char hrs, min, sec;
	int ret = 0;

	if (!mrst->irq)
		return -EIO;

	hrs = t->time.tm_hour;
	min = t->time.tm_min;
	sec = t->time.tm_sec;

	spin_lock_irq(&rtc_lock);
	/* Next rtc irq must not be from previous alarm setting */
	mrst_irq_disable(mrst, RTC_AIE);

	/* Update alarm */
	vrtc_cmos_write(hrs, RTC_HOURS_ALARM);
	vrtc_cmos_write(min, RTC_MINUTES_ALARM);
	vrtc_cmos_write(sec, RTC_SECONDS_ALARM);

	spin_unlock_irq(&rtc_lock);

	ret = intel_scu_ipc_simple_command(IPCMSG_VRTC, IPC_CMD_VRTC_SETALARM);
	if (ret)
		return ret;

	spin_lock_irq(&rtc_lock);
	if (t->enabled)
		mrst_irq_enable(mrst, RTC_AIE);

	spin_unlock_irq(&rtc_lock);

	return 0;
}

/* Currently, the vRTC doesn't support UIE ON/OFF */
static int mrst_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
	struct mrst_rtc	*mrst = dev_get_drvdata(dev);
	unsigned long	flags;

	spin_lock_irqsave(&rtc_lock, flags);
	if (enabled)
		mrst_irq_enable(mrst, RTC_AIE);
	else
		mrst_irq_disable(mrst, RTC_AIE);
	spin_unlock_irqrestore(&rtc_lock, flags);
	return 0;
}


#if IS_ENABLED(CONFIG_RTC_INTF_PROC)

static int mrst_procfs(struct device *dev, struct seq_file *seq)
{
	unsigned char	rtc_control;

	spin_lock_irq(&rtc_lock);
	rtc_control = vrtc_cmos_read(RTC_CONTROL);
	spin_unlock_irq(&rtc_lock);

	seq_printf(seq,
		   "periodic_IRQ\t: %s\n"
		   "alarm\t\t: %s\n"
		   "BCD\t\t: no\n"
		   "periodic_freq\t: daily (not adjustable)\n",
		   (rtc_control & RTC_PIE) ? "on" : "off",
		   (rtc_control & RTC_AIE) ? "on" : "off");

	return 0;
}

#else
#define	mrst_procfs	NULL
#endif

static const struct rtc_class_ops mrst_rtc_ops = {
	.read_time	= mrst_read_time,
	.set_time	= mrst_set_time,
	.read_alarm	= mrst_read_alarm,
	.set_alarm	= mrst_set_alarm,
	.proc		= mrst_procfs,
	.alarm_irq_enable = mrst_rtc_alarm_irq_enable,
};

static struct mrst_rtc	mrst_rtc;

/*
 * When vRTC IRQ is captured by SCU FW, FW will clear the AIE bit in
 * Reg B, so no need for this driver to clear it
 */
static irqreturn_t mrst_rtc_irq(int irq, void *p)
{
	u8 irqstat;

	spin_lock(&rtc_lock);
	/* This read will clear all IRQ flags inside Reg C */
	irqstat = vrtc_cmos_read(RTC_INTR_FLAGS);
	spin_unlock(&rtc_lock);

	irqstat &= RTC_IRQMASK | RTC_IRQF;
	if (is_intr(irqstat)) {
		rtc_update_irq(p, 1, irqstat);
		return IRQ_HANDLED;
	}
	return IRQ_NONE;
}

static int vrtc_mrst_do_probe(struct device *dev, struct resource *iomem,
			      int rtc_irq)
{
	int retval = 0;
	unsigned char rtc_control;

	/* There can be only one ... */
	if (mrst_rtc.dev)
		return -EBUSY;

	if (!iomem)
		return -ENODEV;

	iomem = devm_request_mem_region(dev, iomem->start, resource_size(iomem),
					driver_name);
	if (!iomem) {
		dev_dbg(dev, "i/o mem already in use.\n");
		return -EBUSY;
	}

	mrst_rtc.irq = rtc_irq;
	mrst_rtc.dev = dev;
	dev_set_drvdata(dev, &mrst_rtc);

	mrst_rtc.rtc = devm_rtc_allocate_device(dev);
	if (IS_ERR(mrst_rtc.rtc))
		return PTR_ERR(mrst_rtc.rtc);

	mrst_rtc.rtc->ops = &mrst_rtc_ops;

	rename_region(iomem, dev_name(&mrst_rtc.rtc->dev));

	spin_lock_irq(&rtc_lock);
	mrst_irq_disable(&mrst_rtc, RTC_PIE | RTC_AIE);
	rtc_control = vrtc_cmos_read(RTC_CONTROL);
	spin_unlock_irq(&rtc_lock);

	if (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY)))
		dev_dbg(dev, "TODO: support more than 24-hr BCD mode\n");

	if (rtc_irq) {
		retval = devm_request_irq(dev, rtc_irq, mrst_rtc_irq,
					  0, dev_name(&mrst_rtc.rtc->dev),
					  mrst_rtc.rtc);
		if (retval < 0) {
			dev_dbg(dev, "IRQ %d is already in use, err %d\n",
				rtc_irq, retval);
			goto cleanup0;
		}
	}

	retval = rtc_register_device(mrst_rtc.rtc);
	if (retval)
		goto cleanup0;

	dev_dbg(dev, "initialised\n");
	return 0;

cleanup0:
	mrst_rtc.dev = NULL;
	dev_err(dev, "rtc-mrst: unable to initialise\n");
	return retval;
}

static void rtc_mrst_do_shutdown(void)
{
	spin_lock_irq(&rtc_lock);
	mrst_irq_disable(&mrst_rtc, RTC_IRQMASK);
	spin_unlock_irq(&rtc_lock);
}

static void rtc_mrst_do_remove(struct device *dev)
{
	struct mrst_rtc	*mrst = dev_get_drvdata(dev);

	rtc_mrst_do_shutdown();

	mrst->rtc = NULL;
	mrst->dev = NULL;
}

#ifdef CONFIG_PM_SLEEP
static int mrst_suspend(struct device *dev)
{
	struct mrst_rtc	*mrst = dev_get_drvdata(dev);
	unsigned char	tmp;

	/* Only the alarm might be a wakeup event source */
	spin_lock_irq(&rtc_lock);
	mrst->suspend_ctrl = tmp = vrtc_cmos_read(RTC_CONTROL);
	if (tmp & (RTC_PIE | RTC_AIE)) {
		unsigned char	mask;

		if (device_may_wakeup(dev))
			mask = RTC_IRQMASK & ~RTC_AIE;
		else
			mask = RTC_IRQMASK;
		tmp &= ~mask;
		vrtc_cmos_write(tmp, RTC_CONTROL);

		mrst_checkintr(mrst, tmp);
	}
	spin_unlock_irq(&rtc_lock);

	if (tmp & RTC_AIE) {
		mrst->enabled_wake = 1;
		enable_irq_wake(mrst->irq);
	}

	dev_dbg(&mrst_rtc.rtc->dev, "suspend%s, ctrl %02x\n",
			(tmp & RTC_AIE) ? ", alarm may wake" : "",
			tmp);

	return 0;
}

/*
 * We want RTC alarms to wake us from the deep power saving state
 */
static inline int mrst_poweroff(struct device *dev)
{
	return mrst_suspend(dev);
}

static int mrst_resume(struct device *dev)
{
	struct mrst_rtc	*mrst = dev_get_drvdata(dev);
	unsigned char tmp = mrst->suspend_ctrl;

	/* Re-enable any irqs previously active */
	if (tmp & RTC_IRQMASK) {
		unsigned char	mask;

		if (mrst->enabled_wake) {
			disable_irq_wake(mrst->irq);
			mrst->enabled_wake = 0;
		}

		spin_lock_irq(&rtc_lock);
		do {
			vrtc_cmos_write(tmp, RTC_CONTROL);

			mask = vrtc_cmos_read(RTC_INTR_FLAGS);
			mask &= (tmp & RTC_IRQMASK) | RTC_IRQF;
			if (!is_intr(mask))
				break;

			rtc_update_irq(mrst->rtc, 1, mask);
			tmp &= ~RTC_AIE;
		} while (mask & RTC_AIE);
		spin_unlock_irq(&rtc_lock);
	}

	dev_dbg(&mrst_rtc.rtc->dev, "resume, ctrl %02x\n", tmp);

	return 0;
}

static SIMPLE_DEV_PM_OPS(mrst_pm_ops, mrst_suspend, mrst_resume);
#define MRST_PM_OPS (&mrst_pm_ops)

#else
#define MRST_PM_OPS NULL

static inline int mrst_poweroff(struct device *dev)
{
	return -ENOSYS;
}

#endif

static int vrtc_mrst_platform_probe(struct platform_device *pdev)
{
	return vrtc_mrst_do_probe(&pdev->dev,
			platform_get_resource(pdev, IORESOURCE_MEM, 0),
			platform_get_irq(pdev, 0));
}

static int vrtc_mrst_platform_remove(struct platform_device *pdev)
{
	rtc_mrst_do_remove(&pdev->dev);
	return 0;
}

static void vrtc_mrst_platform_shutdown(struct platform_device *pdev)
{
	if (system_state == SYSTEM_POWER_OFF && !mrst_poweroff(&pdev->dev))
		return;

	rtc_mrst_do_shutdown();
}

MODULE_ALIAS("platform:vrtc_mrst");

static struct platform_driver vrtc_mrst_platform_driver = {
	.probe		= vrtc_mrst_platform_probe,
	.remove		= vrtc_mrst_platform_remove,
	.shutdown	= vrtc_mrst_platform_shutdown,
	.driver = {
		.name	= driver_name,
		.pm	= MRST_PM_OPS,
	}
};

module_platform_driver(vrtc_mrst_platform_driver);

MODULE_AUTHOR("Jacob Pan; Feng Tang");
MODULE_DESCRIPTION("Driver for Moorestown virtual RTC");
MODULE_LICENSE("GPL");
Commit	Line	Data
0146f261 FT	1	/*
	2	* rtc-mrst.c: Driver for Moorestown virtual RTC
	3	*
	4	* (C) Copyright 2009 Intel Corporation
	5	* Author: Jacob Pan (jacob.jun.pan@intel.com)
	6	* Feng Tang (feng.tang@intel.com)
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License
	10	* as published by the Free Software Foundation; version 2
	11	* of the License.
	12	*
	13	* Note:
	14	* VRTC is emulated by system controller firmware, the real HW
	15	* RTC is located in the PMIC device. SCU FW shadows PMIC RTC
	16	* in a memory mapped IO space that is visible to the host IA
	17	* processor.
	18	*
	19	* This driver is based upon drivers/rtc/rtc-cmos.c
	20	*/
	21
	22	/*
	23	* Note:
	24	* * vRTC only supports binary mode and 24H mode
	25	* * vRTC only support PIE and AIE, no UIE, and its PIE only happens
	26	* at 23:59:59pm everyday, no support for adjustable frequency
	27	* * Alarm function is also limited to hr/min/sec.
	28	*/
	29
	30	#include <linux/mod_devicetable.h>
	31	#include <linux/platform_device.h>
	32	#include <linux/interrupt.h>
	33	#include <linux/spinlock.h>
	34	#include <linux/kernel.h>
463a8630	35	#include <linux/mc146818rtc.h>
0146f261 FT	36	#include <linux/module.h>
	37	#include <linux/init.h>
	38	#include <linux/sfi.h>
	39
0146f261	40	#include <asm/intel_scu_ipc.h>
05454c26 KS	41	#include <asm/intel-mid.h>
05454c26 KS	42	#include <asm/intel_mid_vrtc.h>
0146f261 FT	43
	44	struct mrst_rtc {
	45	struct rtc_device *rtc;
	46	struct device *dev;
	47	int irq;
0146f261 FT	48
	49	u8 enabled_wake;
	50	u8 suspend_ctrl;
	51	};
	52
	53	static const char driver_name[] = "rtc_mrst";
	54
	55	#define RTC_IRQMASK (RTC_PF \| RTC_AF)
	56
	57	static inline int is_intr(u8 rtc_intr)
	58	{
	59	if (!(rtc_intr & RTC_IRQF))
	60	return 0;
	61	return rtc_intr & RTC_IRQMASK;
	62	}
	63
168202c7 FT	64	static inline unsigned char vrtc_is_updating(void)
	65	{
	66	unsigned char uip;
	67	unsigned long flags;
	68
	69	spin_lock_irqsave(&rtc_lock, flags);
	70	uip = (vrtc_cmos_read(RTC_FREQ_SELECT) & RTC_UIP);
	71	spin_unlock_irqrestore(&rtc_lock, flags);
	72	return uip;
	73	}
	74
0146f261 FT	75	/*
	76	* rtc_time's year contains the increment over 1900, but vRTC's YEAR
	77	* register can't be programmed to value larger than 0x64, so vRTC
57e6319d	78	* driver chose to use 1972 (1970 is UNIX time start point) as the base,
d3e1884b FT	79	* and does the translation at read/write time.
d3e1884b FT	80	*
57e6319d	81	* Why not just use 1970 as the offset? it's because using 1972 will
d3e1884b	82	* make it consistent in leap year setting for both vrtc and low-level
57e6319d FT	83	* physical rtc devices. Then why not use 1960 as the offset? If we use
	84	* 1960, for a device's first use, its YEAR register is 0 and the system
	85	* year will be parsed as 1960 which is not a valid UNIX time and will
	86	* cause many applications to fail mysteriously.
0146f261 FT	87	*/
	88	static int mrst_read_time(struct device dev, struct rtc_time time)
	89	{
	90	unsigned long flags;
	91
168202c7	92	if (vrtc_is_updating())
c6b5eb8d	93	msleep(20);
0146f261 FT	94
	95	spin_lock_irqsave(&rtc_lock, flags);
	96	time->tm_sec = vrtc_cmos_read(RTC_SECONDS);
	97	time->tm_min = vrtc_cmos_read(RTC_MINUTES);
	98	time->tm_hour = vrtc_cmos_read(RTC_HOURS);
	99	time->tm_mday = vrtc_cmos_read(RTC_DAY_OF_MONTH);
	100	time->tm_mon = vrtc_cmos_read(RTC_MONTH);
	101	time->tm_year = vrtc_cmos_read(RTC_YEAR);
	102	spin_unlock_irqrestore(&rtc_lock, flags);
	103
57e6319d FT	104	/* Adjust for the 1972/1900 */
57e6319d FT	105	time->tm_year += 72;
0146f261	106	time->tm_mon--;
22652ba7	107	return 0;
0146f261 FT	108	}
	109
	110	static int mrst_set_time(struct device dev, struct rtc_time time)
	111	{
	112	int ret;
	113	unsigned long flags;
	114	unsigned char mon, day, hrs, min, sec;
	115	unsigned int yrs;
	116
	117	yrs = time->tm_year;
	118	mon = time->tm_mon + 1; /* tm_mon starts at zero */
	119	day = time->tm_mday;
	120	hrs = time->tm_hour;
	121	min = time->tm_min;
	122	sec = time->tm_sec;
	123
f441f98f	124	if (yrs < 72 \|\| yrs > 172)
0146f261	125	return -EINVAL;
57e6319d	126	yrs -= 72;
0146f261 FT	127
	128	spin_lock_irqsave(&rtc_lock, flags);
	129
	130	vrtc_cmos_write(yrs, RTC_YEAR);
	131	vrtc_cmos_write(mon, RTC_MONTH);
	132	vrtc_cmos_write(day, RTC_DAY_OF_MONTH);
	133	vrtc_cmos_write(hrs, RTC_HOURS);
	134	vrtc_cmos_write(min, RTC_MINUTES);
	135	vrtc_cmos_write(sec, RTC_SECONDS);
	136
	137	spin_unlock_irqrestore(&rtc_lock, flags);
	138
	139	ret = intel_scu_ipc_simple_command(IPCMSG_VRTC, IPC_CMD_VRTC_SETTIME);
	140	return ret;
	141	}
	142
	143	static int mrst_read_alarm(struct device dev, struct rtc_wkalrm t)
	144	{
	145	struct mrst_rtc *mrst = dev_get_drvdata(dev);
	146	unsigned char rtc_control;
	147
	148	if (mrst->irq <= 0)
	149	return -EIO;
	150
0146f261 FT	151	/* vRTC only supports binary mode */
	152	spin_lock_irq(&rtc_lock);
	153	t->time.tm_sec = vrtc_cmos_read(RTC_SECONDS_ALARM);
	154	t->time.tm_min = vrtc_cmos_read(RTC_MINUTES_ALARM);
	155	t->time.tm_hour = vrtc_cmos_read(RTC_HOURS_ALARM);
	156
	157	rtc_control = vrtc_cmos_read(RTC_CONTROL);
	158	spin_unlock_irq(&rtc_lock);
	159
	160	t->enabled = !!(rtc_control & RTC_AIE);
	161	t->pending = 0;
	162
	163	return 0;
	164	}
	165
	166	static void mrst_checkintr(struct mrst_rtc *mrst, unsigned char rtc_control)
	167	{
	168	unsigned char rtc_intr;
	169
	170	/*
	171	* NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
	172	* allegedly some older rtcs need that to handle irqs properly
	173	*/
	174	rtc_intr = vrtc_cmos_read(RTC_INTR_FLAGS);
	175	rtc_intr &= (rtc_control & RTC_IRQMASK) \| RTC_IRQF;
	176	if (is_intr(rtc_intr))
	177	rtc_update_irq(mrst->rtc, 1, rtc_intr);
	178	}
	179
	180	static void mrst_irq_enable(struct mrst_rtc *mrst, unsigned char mask)
	181	{
	182	unsigned char rtc_control;
	183
	184	/*
	185	* Flush any pending IRQ status, notably for update irqs,
	186	* before we enable new IRQs
	187	*/
	188	rtc_control = vrtc_cmos_read(RTC_CONTROL);
	189	mrst_checkintr(mrst, rtc_control);
	190
	191	rtc_control \|= mask;
	192	vrtc_cmos_write(rtc_control, RTC_CONTROL);
	193
	194	mrst_checkintr(mrst, rtc_control);
	195	}
	196
	197	static void mrst_irq_disable(struct mrst_rtc *mrst, unsigned char mask)
	198	{
	199	unsigned char rtc_control;
	200
	201	rtc_control = vrtc_cmos_read(RTC_CONTROL);
	202	rtc_control &= ~mask;
	203	vrtc_cmos_write(rtc_control, RTC_CONTROL);
	204	mrst_checkintr(mrst, rtc_control);
	205	}
	206
	207	static int mrst_set_alarm(struct device dev, struct rtc_wkalrm t)
	208	{
	209	struct mrst_rtc *mrst = dev_get_drvdata(dev);
	210	unsigned char hrs, min, sec;
	211	int ret = 0;
	212
	213	if (!mrst->irq)
	214	return -EIO;
215
216	hrs = t->time.tm_hour;
217	min = t->time.tm_min;
218	sec = t->time.tm_sec;
219
220	spin_lock_irq(&rtc_lock);
221	/* Next rtc irq must not be from previous alarm setting */
222	mrst_irq_disable(mrst, RTC_AIE);
223
224	/* Update alarm */
225	vrtc_cmos_write(hrs, RTC_HOURS_ALARM);
226	vrtc_cmos_write(min, RTC_MINUTES_ALARM);
227	vrtc_cmos_write(sec, RTC_SECONDS_ALARM);
228
229	spin_unlock_irq(&rtc_lock);
230
231	ret = intel_scu_ipc_simple_command(IPCMSG_VRTC, IPC_CMD_VRTC_SETALARM);
232	if (ret)
233	return ret;
234
235	spin_lock_irq(&rtc_lock);
236	if (t->enabled)
237	mrst_irq_enable(mrst, RTC_AIE);
238
239	spin_unlock_irq(&rtc_lock);
240
241	return 0;
242	}
243
0146f261	244	/* Currently, the vRTC doesn't support UIE ON/OFF */
16380c15	245	static int mrst_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
0146f261 FT	246	{
	247	struct mrst_rtc *mrst = dev_get_drvdata(dev);
	248	unsigned long flags;
	249
0146f261	250	spin_lock_irqsave(&rtc_lock, flags);
16380c15	251	if (enabled)
0146f261	252	mrst_irq_enable(mrst, RTC_AIE);
16380c15 JS	253	else
16380c15 JS	254	mrst_irq_disable(mrst, RTC_AIE);
0146f261 FT	255	spin_unlock_irqrestore(&rtc_lock, flags);
	256	return 0;
	257	}
	258
0146f261	259
6fca3fc5	260	#if IS_ENABLED(CONFIG_RTC_INTF_PROC)
0146f261 FT	261
	262	static int mrst_procfs(struct device dev, struct seq_file seq)
	263	{
de96bc39	264	unsigned char rtc_control;
0146f261 FT	265
	266	spin_lock_irq(&rtc_lock);
	267	rtc_control = vrtc_cmos_read(RTC_CONTROL);
0146f261 FT	268	spin_unlock_irq(&rtc_lock);
0146f261 FT	269
4395eb1f JP	270	seq_printf(seq,
	271	"periodic_IRQ\t: %s\n"
	272	"alarm\t\t: %s\n"
	273	"BCD\t\t: no\n"
	274	"periodic_freq\t: daily (not adjustable)\n",
	275	(rtc_control & RTC_PIE) ? "on" : "off",
	276	(rtc_control & RTC_AIE) ? "on" : "off");
	277
	278	return 0;
0146f261 FT	279	}
	280
	281	#else
	282	#define mrst_procfs NULL
	283	#endif
	284
	285	static const struct rtc_class_ops mrst_rtc_ops = {
0146f261 FT	286	.read_time = mrst_read_time,
	287	.set_time = mrst_set_time,
	288	.read_alarm = mrst_read_alarm,
	289	.set_alarm = mrst_set_alarm,
	290	.proc = mrst_procfs,
16380c15	291	.alarm_irq_enable = mrst_rtc_alarm_irq_enable,
0146f261 FT	292	};
	293
	294	static struct mrst_rtc mrst_rtc;
	295
	296	/*
	297	* When vRTC IRQ is captured by SCU FW, FW will clear the AIE bit in
	298	* Reg B, so no need for this driver to clear it
	299	*/
	300	static irqreturn_t mrst_rtc_irq(int irq, void *p)
	301	{
	302	u8 irqstat;
	303
	304	spin_lock(&rtc_lock);
	305	/* This read will clear all IRQ flags inside Reg C */
	306	irqstat = vrtc_cmos_read(RTC_INTR_FLAGS);
	307	spin_unlock(&rtc_lock);
	308
	309	irqstat &= RTC_IRQMASK \| RTC_IRQF;
	310	if (is_intr(irqstat)) {
	311	rtc_update_irq(p, 1, irqstat);
	312	return IRQ_HANDLED;
	313	}
	314	return IRQ_NONE;
	315	}
	316
5a167f45 GKH	317	static int vrtc_mrst_do_probe(struct device dev, struct resource iomem,
5a167f45 GKH	318	int rtc_irq)
0146f261 FT	319	{
	320	int retval = 0;
	321	unsigned char rtc_control;
	322
	323	/* There can be only one ... */
	324	if (mrst_rtc.dev)
	325	return -EBUSY;
	326
	327	if (!iomem)
	328	return -ENODEV;
	329
32b41f93 AB	330	iomem = devm_request_mem_region(dev, iomem->start, resource_size(iomem),
32b41f93 AB	331	driver_name);
0146f261 FT	332	if (!iomem) {
	333	dev_dbg(dev, "i/o mem already in use.\n");
	334	return -EBUSY;
	335	}
	336
	337	mrst_rtc.irq = rtc_irq;
de97a21a FT	338	mrst_rtc.dev = dev;
de97a21a FT	339	dev_set_drvdata(dev, &mrst_rtc);
0146f261	340
32b41f93 AB	341	mrst_rtc.rtc = devm_rtc_allocate_device(dev);
	342	if (IS_ERR(mrst_rtc.rtc))
	343	return PTR_ERR(mrst_rtc.rtc);
	344
	345	mrst_rtc.rtc->ops = &mrst_rtc_ops;
0146f261	346
0146f261 FT	347	rename_region(iomem, dev_name(&mrst_rtc.rtc->dev));
	348
	349	spin_lock_irq(&rtc_lock);
	350	mrst_irq_disable(&mrst_rtc, RTC_PIE \| RTC_AIE);
	351	rtc_control = vrtc_cmos_read(RTC_CONTROL);
	352	spin_unlock_irq(&rtc_lock);
	353
	354	if (!(rtc_control & RTC_24H) \|\| (rtc_control & (RTC_DM_BINARY)))
	355	dev_dbg(dev, "TODO: support more than 24-hr BCD mode\n");
	356
	357	if (rtc_irq) {
32b41f93 AB	358	retval = devm_request_irq(dev, rtc_irq, mrst_rtc_irq,
	359	0, dev_name(&mrst_rtc.rtc->dev),
	360	mrst_rtc.rtc);
0146f261 FT	361	if (retval < 0) {
	362	dev_dbg(dev, "IRQ %d is already in use, err %d\n",
	363	rtc_irq, retval);
32b41f93	364	goto cleanup0;
0146f261 FT	365	}
0146f261 FT	366	}
32b41f93 AB	367
32b41f93 AB	368	retval = rtc_register_device(mrst_rtc.rtc);
ca95ef7c	369	if (retval)
32b41f93	370	goto cleanup0;
32b41f93	371
0146f261 FT	372	dev_dbg(dev, "initialised\n");
	373	return 0;
	374
0146f261	375	cleanup0:
de97a21a	376	mrst_rtc.dev = NULL;
0146f261 FT	377	dev_err(dev, "rtc-mrst: unable to initialise\n");
	378	return retval;
	379	}
	380
	381	static void rtc_mrst_do_shutdown(void)
	382	{
	383	spin_lock_irq(&rtc_lock);
	384	mrst_irq_disable(&mrst_rtc, RTC_IRQMASK);
	385	spin_unlock_irq(&rtc_lock);
	386	}
	387
5a167f45	388	static void rtc_mrst_do_remove(struct device *dev)
0146f261 FT	389	{
0146f261 FT	390	struct mrst_rtc *mrst = dev_get_drvdata(dev);
0146f261 FT	391
	392	rtc_mrst_do_shutdown();
	393
0146f261	394	mrst->rtc = NULL;
0146f261	395	mrst->dev = NULL;
0146f261 FT	396	}
0146f261 FT	397
ddd2a30d LPC	398	#ifdef CONFIG_PM_SLEEP
ddd2a30d LPC	399	static int mrst_suspend(struct device *dev)
0146f261 FT	400	{
	401	struct mrst_rtc *mrst = dev_get_drvdata(dev);
	402	unsigned char tmp;
	403
	404	/* Only the alarm might be a wakeup event source */
	405	spin_lock_irq(&rtc_lock);
	406	mrst->suspend_ctrl = tmp = vrtc_cmos_read(RTC_CONTROL);
	407	if (tmp & (RTC_PIE \| RTC_AIE)) {
	408	unsigned char mask;
	409
	410	if (device_may_wakeup(dev))
	411	mask = RTC_IRQMASK & ~RTC_AIE;
	412	else
	413	mask = RTC_IRQMASK;
	414	tmp &= ~mask;
	415	vrtc_cmos_write(tmp, RTC_CONTROL);
	416
	417	mrst_checkintr(mrst, tmp);
	418	}
	419	spin_unlock_irq(&rtc_lock);
	420
	421	if (tmp & RTC_AIE) {
	422	mrst->enabled_wake = 1;
	423	enable_irq_wake(mrst->irq);
	424	}
	425
	426	dev_dbg(&mrst_rtc.rtc->dev, "suspend%s, ctrl %02x\n",
	427	(tmp & RTC_AIE) ? ", alarm may wake" : "",
	428	tmp);
	429
	430	return 0;
	431	}
	432
	433	/*
	434	* We want RTC alarms to wake us from the deep power saving state
	435	*/
	436	static inline int mrst_poweroff(struct device *dev)
	437	{
ddd2a30d	438	return mrst_suspend(dev);
0146f261 FT	439	}
	440
	441	static int mrst_resume(struct device *dev)
	442	{
	443	struct mrst_rtc *mrst = dev_get_drvdata(dev);
	444	unsigned char tmp = mrst->suspend_ctrl;
	445
	446	/* Re-enable any irqs previously active */
	447	if (tmp & RTC_IRQMASK) {
	448	unsigned char mask;
	449
	450	if (mrst->enabled_wake) {
	451	disable_irq_wake(mrst->irq);
	452	mrst->enabled_wake = 0;
	453	}
	454
	455	spin_lock_irq(&rtc_lock);
	456	do {
	457	vrtc_cmos_write(tmp, RTC_CONTROL);
	458
	459	mask = vrtc_cmos_read(RTC_INTR_FLAGS);
	460	mask &= (tmp & RTC_IRQMASK) \| RTC_IRQF;
	461	if (!is_intr(mask))
	462	break;
	463
	464	rtc_update_irq(mrst->rtc, 1, mask);
	465	tmp &= ~RTC_AIE;
	466	} while (mask & RTC_AIE);
	467	spin_unlock_irq(&rtc_lock);
	468	}
	469
	470	dev_dbg(&mrst_rtc.rtc->dev, "resume, ctrl %02x\n", tmp);
	471
	472	return 0;
	473	}
	474
ddd2a30d LPC	475	static SIMPLE_DEV_PM_OPS(mrst_pm_ops, mrst_suspend, mrst_resume);
	476	#define MRST_PM_OPS (&mrst_pm_ops)
	477
0146f261	478	#else
ddd2a30d	479	#define MRST_PM_OPS NULL
0146f261 FT	480
	481	static inline int mrst_poweroff(struct device *dev)
	482	{
	483	return -ENOSYS;
	484	}
	485
	486	#endif
	487
5a167f45	488	static int vrtc_mrst_platform_probe(struct platform_device *pdev)
0146f261 FT	489	{
	490	return vrtc_mrst_do_probe(&pdev->dev,
	491	platform_get_resource(pdev, IORESOURCE_MEM, 0),
	492	platform_get_irq(pdev, 0));
	493	}
	494
5a167f45	495	static int vrtc_mrst_platform_remove(struct platform_device *pdev)
0146f261 FT	496	{
	497	rtc_mrst_do_remove(&pdev->dev);
	498	return 0;
	499	}
	500
	501	static void vrtc_mrst_platform_shutdown(struct platform_device *pdev)
	502	{
	503	if (system_state == SYSTEM_POWER_OFF && !mrst_poweroff(&pdev->dev))
	504	return;
	505
	506	rtc_mrst_do_shutdown();
	507	}
	508
	509	MODULE_ALIAS("platform:vrtc_mrst");
	510
	511	static struct platform_driver vrtc_mrst_platform_driver = {
	512	.probe = vrtc_mrst_platform_probe,
5a167f45	513	.remove = vrtc_mrst_platform_remove,
0146f261 FT	514	.shutdown = vrtc_mrst_platform_shutdown,
0146f261 FT	515	.driver = {
ddd2a30d LPC	516	.name = driver_name,
ddd2a30d LPC	517	.pm = MRST_PM_OPS,
0146f261 FT	518	}
	519	};
	520
0c4eae66	521	module_platform_driver(vrtc_mrst_platform_driver);
0146f261 FT	522
	523	MODULE_AUTHOR("Jacob Pan; Feng Tang");
	524	MODULE_DESCRIPTION("Driver for Moorestown virtual RTC");
	525	MODULE_LICENSE("GPL");