[deliverable/linux.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/module.h>
#include <linux/init.h>
#include <linux/sfi.h>

#include <asm-generic/rtc.h>
#include <asm/intel_scu_ipc.h>
#include <asm/mrst.h>
#include <asm/mrst-vrtc.h>

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

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

/*
 * 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 1960 (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 1960 will
 * make it consistent in leap year setting for both vrtc and low-level
 * physical rtc devices.
 */
static int mrst_read_time(struct device *dev, struct rtc_time *time)
{
	unsigned long flags;

	if (rtc_is_updating())
		mdelay(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 1960/1900 */
	time->tm_year += 60;
	time->tm_mon--;
	return RTC_24H;
}

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 < 70 || yrs > 138)
		return -EINVAL;
	yrs -= 60;

	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;

	/* Basic alarms only support hour, minute, and seconds fields.
	 * Some also support day and month, for alarms up to a year in
	 * the future.
	 */
	t->time.tm_mday = -1;
	t->time.tm_mon = -1;
	t->time.tm_year = -1;

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

static int mrst_irq_set_state(struct device *dev, int enabled)
{
	struct mrst_rtc	*mrst = dev_get_drvdata(dev);
	unsigned long	flags;

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

	spin_lock_irqsave(&rtc_lock, flags);

	if (enabled)
		mrst_irq_enable(mrst, RTC_PIE);
	else
		mrst_irq_disable(mrst, RTC_PIE);

	spin_unlock_irqrestore(&rtc_lock, flags);
	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 defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)

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

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

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

#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,
	.irq_set_state	= mrst_irq_set_state,
	.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 __init
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 = request_mem_region(iomem->start,
			iomem->end + 1 - iomem->start,
			driver_name);
	if (!iomem) {
		dev_dbg(dev, "i/o mem already in use.\n");
		return -EBUSY;
	}

	mrst_rtc.irq = rtc_irq;
	mrst_rtc.iomem = iomem;

	mrst_rtc.rtc = rtc_device_register(driver_name, dev,
				&mrst_rtc_ops, THIS_MODULE);
	if (IS_ERR(mrst_rtc.rtc)) {
		retval = PTR_ERR(mrst_rtc.rtc);
		goto cleanup0;
	}

	mrst_rtc.dev = dev;
	dev_set_drvdata(dev, &mrst_rtc);
	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 = request_irq(rtc_irq, mrst_rtc_irq,
				IRQF_DISABLED, 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 cleanup1;
		}
	}
	dev_dbg(dev, "initialised\n");
	return 0;

cleanup1:
	mrst_rtc.dev = NULL;
	rtc_device_unregister(mrst_rtc.rtc);
cleanup0:
	release_region(iomem->start, iomem->end + 1 - iomem->start);
	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 __exit rtc_mrst_do_remove(struct device *dev)
{
	struct mrst_rtc	*mrst = dev_get_drvdata(dev);
	struct resource *iomem;

	rtc_mrst_do_shutdown();

	if (mrst->irq)
		free_irq(mrst->irq, mrst->rtc);

	rtc_device_unregister(mrst->rtc);
	mrst->rtc = NULL;

	iomem = mrst->iomem;
	release_region(iomem->start, iomem->end + 1 - iomem->start);
	mrst->iomem = NULL;

	mrst->dev = NULL;
	dev_set_drvdata(dev, NULL);
}

#ifdef	CONFIG_PM
static int mrst_suspend(struct device *dev, pm_message_t mesg)
{
	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, PMSG_HIBERNATE);
}

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

#else
#define	mrst_suspend	NULL
#define	mrst_resume	NULL

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

#endif

static int __init 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 __exit 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		= __exit_p(vrtc_mrst_platform_remove),
	.shutdown	= vrtc_mrst_platform_shutdown,
	.driver = {
		.name		= (char *) driver_name,
		.suspend	= mrst_suspend,
		.resume		= mrst_resume,
	}
};

static int __init vrtc_mrst_init(void)
{
	return platform_driver_register(&vrtc_mrst_platform_driver);
}

static void __exit vrtc_mrst_exit(void)
{
	platform_driver_unregister(&vrtc_mrst_platform_driver);
}

module_init(vrtc_mrst_init);
module_exit(vrtc_mrst_exit);

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>
	35	#include <linux/module.h>
	36	#include <linux/init.h>
	37	#include <linux/sfi.h>
	38
	39	#include <asm-generic/rtc.h>
	40	#include <asm/intel_scu_ipc.h>
	41	#include <asm/mrst.h>
	42	#include <asm/mrst-vrtc.h>
	43
	44	struct mrst_rtc {
	45	struct rtc_device *rtc;
	46	struct device *dev;
	47	int irq;
	48	struct resource *iomem;
	49
	50	u8 enabled_wake;
	51	u8 suspend_ctrl;
	52	};
	53
	54	static const char driver_name[] = "rtc_mrst";
	55
	56	#define RTC_IRQMASK (RTC_PF \| RTC_AF)
	57
	58	static inline int is_intr(u8 rtc_intr)
	59	{
	60	if (!(rtc_intr & RTC_IRQF))
	61	return 0;
	62	return rtc_intr & RTC_IRQMASK;
	63	}
	64
65	/*
66	* rtc_time's year contains the increment over 1900, but vRTC's YEAR
67	* register can't be programmed to value larger than 0x64, so vRTC
68	* driver chose to use 1960 (1970 is UNIX time start point) as the base,
d3e1884b FT	69	* and does the translation at read/write time.
	70	*
	71	* Why not just use 1970 as the offset? it's because using 1960 will
	72	* make it consistent in leap year setting for both vrtc and low-level
	73	* physical rtc devices.
0146f261 FT	74	*/
	75	static int mrst_read_time(struct device dev, struct rtc_time time)
	76	{
	77	unsigned long flags;
	78
	79	if (rtc_is_updating())
	80	mdelay(20);
	81
	82	spin_lock_irqsave(&rtc_lock, flags);
	83	time->tm_sec = vrtc_cmos_read(RTC_SECONDS);
	84	time->tm_min = vrtc_cmos_read(RTC_MINUTES);
	85	time->tm_hour = vrtc_cmos_read(RTC_HOURS);
	86	time->tm_mday = vrtc_cmos_read(RTC_DAY_OF_MONTH);
	87	time->tm_mon = vrtc_cmos_read(RTC_MONTH);
	88	time->tm_year = vrtc_cmos_read(RTC_YEAR);
	89	spin_unlock_irqrestore(&rtc_lock, flags);
	90
	91	/* Adjust for the 1960/1900 */
	92	time->tm_year += 60;
	93	time->tm_mon--;
	94	return RTC_24H;
	95	}
	96
	97	static int mrst_set_time(struct device dev, struct rtc_time time)
	98	{
	99	int ret;
	100	unsigned long flags;
	101	unsigned char mon, day, hrs, min, sec;
	102	unsigned int yrs;
	103
	104	yrs = time->tm_year;
	105	mon = time->tm_mon + 1; /* tm_mon starts at zero */
	106	day = time->tm_mday;
	107	hrs = time->tm_hour;
	108	min = time->tm_min;
	109	sec = time->tm_sec;
	110
	111	if (yrs < 70 \|\| yrs > 138)
	112	return -EINVAL;
	113	yrs -= 60;
	114
	115	spin_lock_irqsave(&rtc_lock, flags);
	116
	117	vrtc_cmos_write(yrs, RTC_YEAR);
	118	vrtc_cmos_write(mon, RTC_MONTH);
	119	vrtc_cmos_write(day, RTC_DAY_OF_MONTH);
	120	vrtc_cmos_write(hrs, RTC_HOURS);
	121	vrtc_cmos_write(min, RTC_MINUTES);
	122	vrtc_cmos_write(sec, RTC_SECONDS);
	123
	124	spin_unlock_irqrestore(&rtc_lock, flags);
	125
	126	ret = intel_scu_ipc_simple_command(IPCMSG_VRTC, IPC_CMD_VRTC_SETTIME);
	127	return ret;
	128	}
	129
	130	static int mrst_read_alarm(struct device dev, struct rtc_wkalrm t)
	131	{
	132	struct mrst_rtc *mrst = dev_get_drvdata(dev);
	133	unsigned char rtc_control;
	134
	135	if (mrst->irq <= 0)
	136	return -EIO;
	137
138	/* Basic alarms only support hour, minute, and seconds fields.
139	* Some also support day and month, for alarms up to a year in
140	* the future.
141	*/
142	t->time.tm_mday = -1;
143	t->time.tm_mon = -1;
144	t->time.tm_year = -1;
145
146	/* vRTC only supports binary mode */
147	spin_lock_irq(&rtc_lock);
148	t->time.tm_sec = vrtc_cmos_read(RTC_SECONDS_ALARM);
149	t->time.tm_min = vrtc_cmos_read(RTC_MINUTES_ALARM);
150	t->time.tm_hour = vrtc_cmos_read(RTC_HOURS_ALARM);
151
152	rtc_control = vrtc_cmos_read(RTC_CONTROL);
153	spin_unlock_irq(&rtc_lock);
154
155	t->enabled = !!(rtc_control & RTC_AIE);
156	t->pending = 0;
157
158	return 0;
159	}
160
161	static void mrst_checkintr(struct mrst_rtc *mrst, unsigned char rtc_control)
162	{
163	unsigned char rtc_intr;
164
165	/*
166	* NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
167	* allegedly some older rtcs need that to handle irqs properly
168	*/
169	rtc_intr = vrtc_cmos_read(RTC_INTR_FLAGS);
170	rtc_intr &= (rtc_control & RTC_IRQMASK) \| RTC_IRQF;
171	if (is_intr(rtc_intr))
172	rtc_update_irq(mrst->rtc, 1, rtc_intr);
173	}
174
175	static void mrst_irq_enable(struct mrst_rtc *mrst, unsigned char mask)
176	{
177	unsigned char rtc_control;
178
179	/*
180	* Flush any pending IRQ status, notably for update irqs,
181	* before we enable new IRQs
182	*/
183	rtc_control = vrtc_cmos_read(RTC_CONTROL);
184	mrst_checkintr(mrst, rtc_control);
185
186	rtc_control \|= mask;
187	vrtc_cmos_write(rtc_control, RTC_CONTROL);
188
189	mrst_checkintr(mrst, rtc_control);
190	}
191
192	static void mrst_irq_disable(struct mrst_rtc *mrst, unsigned char mask)
193	{
194	unsigned char rtc_control;
195
196	rtc_control = vrtc_cmos_read(RTC_CONTROL);
197	rtc_control &= ~mask;
198	vrtc_cmos_write(rtc_control, RTC_CONTROL);
199	mrst_checkintr(mrst, rtc_control);
200	}
201
202	static int mrst_set_alarm(struct device dev, struct rtc_wkalrm t)
203	{
204	struct mrst_rtc *mrst = dev_get_drvdata(dev);
205	unsigned char hrs, min, sec;
206	int ret = 0;
207
208	if (!mrst->irq)
209	return -EIO;
210
211	hrs = t->time.tm_hour;
212	min = t->time.tm_min;
213	sec = t->time.tm_sec;
214
215	spin_lock_irq(&rtc_lock);
216	/* Next rtc irq must not be from previous alarm setting */
217	mrst_irq_disable(mrst, RTC_AIE);
218
219	/* Update alarm */
220	vrtc_cmos_write(hrs, RTC_HOURS_ALARM);
221	vrtc_cmos_write(min, RTC_MINUTES_ALARM);
222	vrtc_cmos_write(sec, RTC_SECONDS_ALARM);
223
224	spin_unlock_irq(&rtc_lock);
225
226	ret = intel_scu_ipc_simple_command(IPCMSG_VRTC, IPC_CMD_VRTC_SETALARM);
227	if (ret)
228	return ret;
229
230	spin_lock_irq(&rtc_lock);
231	if (t->enabled)
232	mrst_irq_enable(mrst, RTC_AIE);
233
234	spin_unlock_irq(&rtc_lock);
235
236	return 0;
237	}
238
239	static int mrst_irq_set_state(struct device *dev, int enabled)
240	{
241	struct mrst_rtc *mrst = dev_get_drvdata(dev);
242	unsigned long flags;
243
244	if (!mrst->irq)
245	return -ENXIO;
246
247	spin_lock_irqsave(&rtc_lock, flags);
248
249	if (enabled)
250	mrst_irq_enable(mrst, RTC_PIE);
251	else
252	mrst_irq_disable(mrst, RTC_PIE);
253
254	spin_unlock_irqrestore(&rtc_lock, flags);
255	return 0;
256	}
257
0146f261	258	/* Currently, the vRTC doesn't support UIE ON/OFF */
16380c15	259	static int mrst_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
0146f261 FT	260	{
	261	struct mrst_rtc *mrst = dev_get_drvdata(dev);
	262	unsigned long flags;
	263
0146f261	264	spin_lock_irqsave(&rtc_lock, flags);
16380c15	265	if (enabled)
0146f261	266	mrst_irq_enable(mrst, RTC_AIE);
16380c15 JS	267	else
16380c15 JS	268	mrst_irq_disable(mrst, RTC_AIE);
0146f261 FT	269	spin_unlock_irqrestore(&rtc_lock, flags);
	270	return 0;
	271	}
	272
0146f261 FT	273
	274	#if defined(CONFIG_RTC_INTF_PROC) \|\| defined(CONFIG_RTC_INTF_PROC_MODULE)
	275
	276	static int mrst_procfs(struct device dev, struct seq_file seq)
	277	{
	278	unsigned char rtc_control, valid;
	279
	280	spin_lock_irq(&rtc_lock);
	281	rtc_control = vrtc_cmos_read(RTC_CONTROL);
	282	valid = vrtc_cmos_read(RTC_VALID);
	283	spin_unlock_irq(&rtc_lock);
	284
	285	return seq_printf(seq,
	286	"periodic_IRQ\t: %s\n"
	287	"alarm\t\t: %s\n"
	288	"BCD\t\t: no\n"
	289	"periodic_freq\t: daily (not adjustable)\n",
	290	(rtc_control & RTC_PIE) ? "on" : "off",
	291	(rtc_control & RTC_AIE) ? "on" : "off");
	292	}
	293
	294	#else
	295	#define mrst_procfs NULL
	296	#endif
	297
	298	static const struct rtc_class_ops mrst_rtc_ops = {
0146f261 FT	299	.read_time = mrst_read_time,
	300	.set_time = mrst_set_time,
	301	.read_alarm = mrst_read_alarm,
	302	.set_alarm = mrst_set_alarm,
	303	.proc = mrst_procfs,
	304	.irq_set_state = mrst_irq_set_state,
16380c15	305	.alarm_irq_enable = mrst_rtc_alarm_irq_enable,
0146f261 FT	306	};
	307
	308	static struct mrst_rtc mrst_rtc;
	309
	310	/*
	311	* When vRTC IRQ is captured by SCU FW, FW will clear the AIE bit in
	312	* Reg B, so no need for this driver to clear it
	313	*/
	314	static irqreturn_t mrst_rtc_irq(int irq, void *p)
	315	{
	316	u8 irqstat;
	317
	318	spin_lock(&rtc_lock);
	319	/* This read will clear all IRQ flags inside Reg C */
	320	irqstat = vrtc_cmos_read(RTC_INTR_FLAGS);
	321	spin_unlock(&rtc_lock);
	322
	323	irqstat &= RTC_IRQMASK \| RTC_IRQF;
	324	if (is_intr(irqstat)) {
	325	rtc_update_irq(p, 1, irqstat);
	326	return IRQ_HANDLED;
	327	}
	328	return IRQ_NONE;
	329	}
	330
	331	static int __init
	332	vrtc_mrst_do_probe(struct device dev, struct resource iomem, int rtc_irq)
	333	{
	334	int retval = 0;
	335	unsigned char rtc_control;
	336
	337	/* There can be only one ... */
	338	if (mrst_rtc.dev)
	339	return -EBUSY;
	340
	341	if (!iomem)
	342	return -ENODEV;
	343
	344	iomem = request_mem_region(iomem->start,
	345	iomem->end + 1 - iomem->start,
	346	driver_name);
	347	if (!iomem) {
	348	dev_dbg(dev, "i/o mem already in use.\n");
	349	return -EBUSY;
	350	}
	351
	352	mrst_rtc.irq = rtc_irq;
	353	mrst_rtc.iomem = iomem;
	354
	355	mrst_rtc.rtc = rtc_device_register(driver_name, dev,
	356	&mrst_rtc_ops, THIS_MODULE);
	357	if (IS_ERR(mrst_rtc.rtc)) {
	358	retval = PTR_ERR(mrst_rtc.rtc);
	359	goto cleanup0;
	360	}
	361
	362	mrst_rtc.dev = dev;
	363	dev_set_drvdata(dev, &mrst_rtc);
	364	rename_region(iomem, dev_name(&mrst_rtc.rtc->dev));
	365
	366	spin_lock_irq(&rtc_lock);
	367	mrst_irq_disable(&mrst_rtc, RTC_PIE \| RTC_AIE);
	368	rtc_control = vrtc_cmos_read(RTC_CONTROL);
	369	spin_unlock_irq(&rtc_lock);
370
371	if (!(rtc_control & RTC_24H) \|\| (rtc_control & (RTC_DM_BINARY)))
372	dev_dbg(dev, "TODO: support more than 24-hr BCD mode\n");
373
374	if (rtc_irq) {
375	retval = request_irq(rtc_irq, mrst_rtc_irq,
376	IRQF_DISABLED, dev_name(&mrst_rtc.rtc->dev),
377	mrst_rtc.rtc);
378	if (retval < 0) {
379	dev_dbg(dev, "IRQ %d is already in use, err %d\n",
380	rtc_irq, retval);
381	goto cleanup1;
382	}
383	}
384	dev_dbg(dev, "initialised\n");
385	return 0;
386
387	cleanup1:
388	mrst_rtc.dev = NULL;
389	rtc_device_unregister(mrst_rtc.rtc);
390	cleanup0:
391	release_region(iomem->start, iomem->end + 1 - iomem->start);
392	dev_err(dev, "rtc-mrst: unable to initialise\n");
393	return retval;
394	}
395
396	static void rtc_mrst_do_shutdown(void)
397	{
398	spin_lock_irq(&rtc_lock);
399	mrst_irq_disable(&mrst_rtc, RTC_IRQMASK);
400	spin_unlock_irq(&rtc_lock);
401	}
402
403	static void __exit rtc_mrst_do_remove(struct device *dev)
404	{
405	struct mrst_rtc *mrst = dev_get_drvdata(dev);
406	struct resource *iomem;
407
408	rtc_mrst_do_shutdown();
409
410	if (mrst->irq)
411	free_irq(mrst->irq, mrst->rtc);
412
413	rtc_device_unregister(mrst->rtc);
414	mrst->rtc = NULL;
415
416	iomem = mrst->iomem;
417	release_region(iomem->start, iomem->end + 1 - iomem->start);
418	mrst->iomem = NULL;
419
420	mrst->dev = NULL;
421	dev_set_drvdata(dev, NULL);
422	}
423
424	#ifdef CONFIG_PM
425	static int mrst_suspend(struct device *dev, pm_message_t mesg)
426	{
427	struct mrst_rtc *mrst = dev_get_drvdata(dev);
428	unsigned char tmp;
429
430	/* Only the alarm might be a wakeup event source */
431	spin_lock_irq(&rtc_lock);
432	mrst->suspend_ctrl = tmp = vrtc_cmos_read(RTC_CONTROL);
433	if (tmp & (RTC_PIE \| RTC_AIE)) {
434	unsigned char mask;
435
436	if (device_may_wakeup(dev))
437	mask = RTC_IRQMASK & ~RTC_AIE;
438	else
439	mask = RTC_IRQMASK;
440	tmp &= ~mask;
441	vrtc_cmos_write(tmp, RTC_CONTROL);
442
443	mrst_checkintr(mrst, tmp);
444	}
445	spin_unlock_irq(&rtc_lock);
446
447	if (tmp & RTC_AIE) {
448	mrst->enabled_wake = 1;
449	enable_irq_wake(mrst->irq);
450	}
451
452	dev_dbg(&mrst_rtc.rtc->dev, "suspend%s, ctrl %02x\n",
453	(tmp & RTC_AIE) ? ", alarm may wake" : "",
454	tmp);
455
456	return 0;
457	}
458
459	/*
460	* We want RTC alarms to wake us from the deep power saving state
461	*/
462	static inline int mrst_poweroff(struct device *dev)
463	{
464	return mrst_suspend(dev, PMSG_HIBERNATE);
465	}
466
467	static int mrst_resume(struct device *dev)
468	{
469	struct mrst_rtc *mrst = dev_get_drvdata(dev);
470	unsigned char tmp = mrst->suspend_ctrl;
471
472	/* Re-enable any irqs previously active */
473	if (tmp & RTC_IRQMASK) {
474	unsigned char mask;
475
476	if (mrst->enabled_wake) {
477	disable_irq_wake(mrst->irq);
478	mrst->enabled_wake = 0;
479	}
480
481	spin_lock_irq(&rtc_lock);
482	do {
483	vrtc_cmos_write(tmp, RTC_CONTROL);
484
485	mask = vrtc_cmos_read(RTC_INTR_FLAGS);
486	mask &= (tmp & RTC_IRQMASK) \| RTC_IRQF;
487	if (!is_intr(mask))
488	break;
489
490	rtc_update_irq(mrst->rtc, 1, mask);
491	tmp &= ~RTC_AIE;
492	} while (mask & RTC_AIE);
493	spin_unlock_irq(&rtc_lock);
494	}
495
496	dev_dbg(&mrst_rtc.rtc->dev, "resume, ctrl %02x\n", tmp);
497
498	return 0;
499	}
500
501	#else
502	#define mrst_suspend NULL
503	#define mrst_resume NULL
504
505	static inline int mrst_poweroff(struct device *dev)
506	{
507	return -ENOSYS;
508	}
509
510	#endif
511
512	static int __init vrtc_mrst_platform_probe(struct platform_device *pdev)
513	{
514	return vrtc_mrst_do_probe(&pdev->dev,
515	platform_get_resource(pdev, IORESOURCE_MEM, 0),
516	platform_get_irq(pdev, 0));
517	}
518
519	static int __exit vrtc_mrst_platform_remove(struct platform_device *pdev)
520	{
521	rtc_mrst_do_remove(&pdev->dev);
522	return 0;
523	}
524
525	static void vrtc_mrst_platform_shutdown(struct platform_device *pdev)
526	{
527	if (system_state == SYSTEM_POWER_OFF && !mrst_poweroff(&pdev->dev))
528	return;
529
530	rtc_mrst_do_shutdown();
531	}
532
533	MODULE_ALIAS("platform:vrtc_mrst");
534
535	static struct platform_driver vrtc_mrst_platform_driver = {
536	.probe = vrtc_mrst_platform_probe,
537	.remove = __exit_p(vrtc_mrst_platform_remove),
538	.shutdown = vrtc_mrst_platform_shutdown,
539	.driver = {
540	.name = (char *) driver_name,
541	.suspend = mrst_suspend,
542	.resume = mrst_resume,
543	}
544	};
545
546	static int __init vrtc_mrst_init(void)
547	{
548	return platform_driver_register(&vrtc_mrst_platform_driver);
549	}
550
551	static void __exit vrtc_mrst_exit(void)
552	{
553	platform_driver_unregister(&vrtc_mrst_platform_driver);
554	}
555
556	module_init(vrtc_mrst_init);
557	module_exit(vrtc_mrst_exit);
558
559	MODULE_AUTHOR("Jacob Pan; Feng Tang");
560	MODULE_DESCRIPTION("Driver for Moorestown virtual RTC");
561	MODULE_LICENSE("GPL");