[deliverable/linux.git] / arch / x86 / platform / mrst / vrtc.c

/*
 * vrtc.c: Driver for virtual RTC device on Intel MID platform
 *
 * (C) Copyright 2009 Intel Corporation
 *
 * 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 on RTC CMOS driver.
 */

#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/init.h>
#include <linux/sfi.h>
#include <linux/platform_device.h>

#include <asm/mrst.h>
#include <asm/mrst-vrtc.h>
#include <asm/time.h>
#include <asm/fixmap.h>

static unsigned char __iomem *vrtc_virt_base;

unsigned char vrtc_cmos_read(unsigned char reg)
{
	unsigned char retval;

	/* vRTC's registers range from 0x0 to 0xD */
	if (reg > 0xd || !vrtc_virt_base)
		return 0xff;

	lock_cmos_prefix(reg);
	retval = __raw_readb(vrtc_virt_base + (reg << 2));
	lock_cmos_suffix(reg);
	return retval;
}
EXPORT_SYMBOL_GPL(vrtc_cmos_read);

void vrtc_cmos_write(unsigned char val, unsigned char reg)
{
	if (reg > 0xd || !vrtc_virt_base)
		return;

	lock_cmos_prefix(reg);
	__raw_writeb(val, vrtc_virt_base + (reg << 2));
	lock_cmos_suffix(reg);
}
EXPORT_SYMBOL_GPL(vrtc_cmos_write);

unsigned long vrtc_get_time(void)
{
	u8 sec, min, hour, mday, mon;
	unsigned long flags;
	u32 year;

	spin_lock_irqsave(&rtc_lock, flags);

	while ((vrtc_cmos_read(RTC_FREQ_SELECT) & RTC_UIP))
		cpu_relax();

	sec = vrtc_cmos_read(RTC_SECONDS);
	min = vrtc_cmos_read(RTC_MINUTES);
	hour = vrtc_cmos_read(RTC_HOURS);
	mday = vrtc_cmos_read(RTC_DAY_OF_MONTH);
	mon = vrtc_cmos_read(RTC_MONTH);
	year = vrtc_cmos_read(RTC_YEAR);

	spin_unlock_irqrestore(&rtc_lock, flags);

	/* vRTC YEAR reg contains the offset to 1972 */
	year += 1972;

	printk(KERN_INFO "vRTC: sec: %d min: %d hour: %d day: %d "
		"mon: %d year: %d\n", sec, min, hour, mday, mon, year);

	return mktime(year, mon, mday, hour, min, sec);
}

int vrtc_set_mmss(unsigned long nowtime)
{
	unsigned long flags;
	struct rtc_time tm;
	int year;
	int retval = 0;

	rtc_time_to_tm(nowtime, &tm);
	if (!rtc_valid_tm(&tm) && tm.tm_year >= 72) {
		/*
		 * tm.year is the number of years since 1900, and the
		 * vrtc need the years since 1972.
		 */
		year = tm.tm_year - 72;
		spin_lock_irqsave(&rtc_lock, flags);
		vrtc_cmos_write(year, RTC_YEAR);
		vrtc_cmos_write(tm.tm_mon, RTC_MONTH);
		vrtc_cmos_write(tm.tm_mday, RTC_DAY_OF_MONTH);
		vrtc_cmos_write(tm.tm_hour, RTC_HOURS);
		vrtc_cmos_write(tm.tm_min, RTC_MINUTES);
		vrtc_cmos_write(tm.tm_sec, RTC_SECONDS);
		spin_unlock_irqrestore(&rtc_lock, flags);
	} else {
		printk(KERN_ERR
		       "%s: Invalid vRTC value: write of %lx to vRTC failed\n",
			__FUNCTION__, nowtime);
		retval = -EINVAL;
	}
	return retval;
}

void __init mrst_rtc_init(void)
{
	unsigned long vrtc_paddr;

	sfi_table_parse(SFI_SIG_MRTC, NULL, NULL, sfi_parse_mrtc);

	vrtc_paddr = sfi_mrtc_array[0].phys_addr;
	if (!sfi_mrtc_num || !vrtc_paddr)
		return;

	vrtc_virt_base = (void __iomem *)set_fixmap_offset_nocache(FIX_LNW_VRTC,
								vrtc_paddr);
	x86_platform.get_wallclock = vrtc_get_time;
	x86_platform.set_wallclock = vrtc_set_mmss;
}

/*
 * The Moorestown platform has a memory mapped virtual RTC device that emulates
 * the programming interface of the RTC.
 */

static struct resource vrtc_resources[] = {
	[0] = {
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.flags	= IORESOURCE_IRQ,
	}
};

static struct platform_device vrtc_device = {
	.name		= "rtc_mrst",
	.id		= -1,
	.resource	= vrtc_resources,
	.num_resources	= ARRAY_SIZE(vrtc_resources),
};

/* Register the RTC device if appropriate */
static int __init mrst_device_create(void)
{
	/* No Moorestown, no device */
	if (!mrst_identify_cpu())
		return -ENODEV;
	/* No timer, no device */
	if (!sfi_mrtc_num)
		return -ENODEV;

	/* iomem resource */
	vrtc_resources[0].start = sfi_mrtc_array[0].phys_addr;
	vrtc_resources[0].end = sfi_mrtc_array[0].phys_addr +
				MRST_VRTC_MAP_SZ;
	/* irq resource */
	vrtc_resources[1].start = sfi_mrtc_array[0].irq;
	vrtc_resources[1].end = sfi_mrtc_array[0].irq;

	return platform_device_register(&vrtc_device);
}

module_init(mrst_device_create);
Commit	Line	Data
7309282c FT	1	/*
	2	* vrtc.c: Driver for virtual RTC device on Intel MID platform
	3	*
	4	* (C) Copyright 2009 Intel Corporation
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; version 2
	9	* of the License.
	10	*
	11	* Note:
	12	* VRTC is emulated by system controller firmware, the real HW
	13	* RTC is located in the PMIC device. SCU FW shadows PMIC RTC
	14	* in a memory mapped IO space that is visible to the host IA
	15	* processor.
	16	*
	17	* This driver is based on RTC CMOS driver.
	18	*/
	19
	20	#include <linux/kernel.h>
69c60c88	21	#include <linux/export.h>
7309282c FT	22	#include <linux/init.h>
7309282c FT	23	#include <linux/sfi.h>
0146f261	24	#include <linux/platform_device.h>
7309282c FT	25
	26	#include <asm/mrst.h>
	27	#include <asm/mrst-vrtc.h>
	28	#include <asm/time.h>
	29	#include <asm/fixmap.h>
	30
	31	static unsigned char __iomem *vrtc_virt_base;
	32
	33	unsigned char vrtc_cmos_read(unsigned char reg)
	34	{
	35	unsigned char retval;
	36
	37	/* vRTC's registers range from 0x0 to 0xD */
	38	if (reg > 0xd \|\| !vrtc_virt_base)
	39	return 0xff;
	40
	41	lock_cmos_prefix(reg);
	42	retval = __raw_readb(vrtc_virt_base + (reg << 2));
	43	lock_cmos_suffix(reg);
	44	return retval;
	45	}
	46	EXPORT_SYMBOL_GPL(vrtc_cmos_read);
	47
	48	void vrtc_cmos_write(unsigned char val, unsigned char reg)
	49	{
	50	if (reg > 0xd \|\| !vrtc_virt_base)
	51	return;
	52
	53	lock_cmos_prefix(reg);
	54	__raw_writeb(val, vrtc_virt_base + (reg << 2));
	55	lock_cmos_suffix(reg);
	56	}
	57	EXPORT_SYMBOL_GPL(vrtc_cmos_write);
	58
	59	unsigned long vrtc_get_time(void)
	60	{
	61	u8 sec, min, hour, mday, mon;
47997d75	62	unsigned long flags;
7309282c FT	63	u32 year;
7309282c FT	64
47997d75 MF	65	spin_lock_irqsave(&rtc_lock, flags);
47997d75 MF	66
7309282c FT	67	while ((vrtc_cmos_read(RTC_FREQ_SELECT) & RTC_UIP))
	68	cpu_relax();
	69
	70	sec = vrtc_cmos_read(RTC_SECONDS);
	71	min = vrtc_cmos_read(RTC_MINUTES);
	72	hour = vrtc_cmos_read(RTC_HOURS);
	73	mday = vrtc_cmos_read(RTC_DAY_OF_MONTH);
	74	mon = vrtc_cmos_read(RTC_MONTH);
	75	year = vrtc_cmos_read(RTC_YEAR);
	76
47997d75 MF	77	spin_unlock_irqrestore(&rtc_lock, flags);
47997d75 MF	78
57e6319d FT	79	/* vRTC YEAR reg contains the offset to 1972 */
57e6319d FT	80	year += 1972;
7309282c FT	81
	82	printk(KERN_INFO "vRTC: sec: %d min: %d hour: %d day: %d "
	83	"mon: %d year: %d\n", sec, min, hour, mday, mon, year);
	84
	85	return mktime(year, mon, mday, hour, min, sec);
	86	}
	87
7309282c FT	88	int vrtc_set_mmss(unsigned long nowtime)
7309282c FT	89	{
47997d75	90	unsigned long flags;
3195ef59 PB	91	struct rtc_time tm;
	92	int year;
	93	int retval = 0;
	94
	95	rtc_time_to_tm(nowtime, &tm);
	96	if (!rtc_valid_tm(&tm) && tm.tm_year >= 72) {
	97	/*
	98	* tm.year is the number of years since 1900, and the
	99	* vrtc need the years since 1972.
	100	*/
	101	year = tm.tm_year - 72;
	102	spin_lock_irqsave(&rtc_lock, flags);
	103	vrtc_cmos_write(year, RTC_YEAR);
	104	vrtc_cmos_write(tm.tm_mon, RTC_MONTH);
	105	vrtc_cmos_write(tm.tm_mday, RTC_DAY_OF_MONTH);
	106	vrtc_cmos_write(tm.tm_hour, RTC_HOURS);
	107	vrtc_cmos_write(tm.tm_min, RTC_MINUTES);
	108	vrtc_cmos_write(tm.tm_sec, RTC_SECONDS);
	109	spin_unlock_irqrestore(&rtc_lock, flags);
	110	} else {
	111	printk(KERN_ERR
	112	"%s: Invalid vRTC value: write of %lx to vRTC failed\n",
	113	__FUNCTION__, nowtime);
	114	retval = -EINVAL;
	115	}
	116	return retval;
7309282c FT	117	}
	118
	119	void __init mrst_rtc_init(void)
	120	{
09552b26	121	unsigned long vrtc_paddr;
7309282c FT	122
7309282c FT	123	sfi_table_parse(SFI_SIG_MRTC, NULL, NULL, sfi_parse_mrtc);
09552b26 FT	124
09552b26 FT	125	vrtc_paddr = sfi_mrtc_array[0].phys_addr;
168202c7	126	if (!sfi_mrtc_num \|\| !vrtc_paddr)
7309282c FT	127	return;
7309282c FT	128
168202c7 FT	129	vrtc_virt_base = (void __iomem *)set_fixmap_offset_nocache(FIX_LNW_VRTC,
168202c7 FT	130	vrtc_paddr);
7309282c FT	131	x86_platform.get_wallclock = vrtc_get_time;
	132	x86_platform.set_wallclock = vrtc_set_mmss;
	133	}
0146f261 FT	134
	135	/*
	136	* The Moorestown platform has a memory mapped virtual RTC device that emulates
	137	* the programming interface of the RTC.
	138	*/
	139
	140	static struct resource vrtc_resources[] = {
	141	[0] = {
	142	.flags = IORESOURCE_MEM,
	143	},
	144	[1] = {
	145	.flags = IORESOURCE_IRQ,
	146	}
	147	};
	148
	149	static struct platform_device vrtc_device = {
	150	.name = "rtc_mrst",
	151	.id = -1,
	152	.resource = vrtc_resources,
	153	.num_resources = ARRAY_SIZE(vrtc_resources),
	154	};
	155
	156	/* Register the RTC device if appropriate */
	157	static int __init mrst_device_create(void)
	158	{
	159	/* No Moorestown, no device */
	160	if (!mrst_identify_cpu())
	161	return -ENODEV;
	162	/* No timer, no device */
	163	if (!sfi_mrtc_num)
	164	return -ENODEV;
	165
	166	/* iomem resource */
	167	vrtc_resources[0].start = sfi_mrtc_array[0].phys_addr;
	168	vrtc_resources[0].end = sfi_mrtc_array[0].phys_addr +
	169	MRST_VRTC_MAP_SZ;
	170	/* irq resource */
	171	vrtc_resources[1].start = sfi_mrtc_array[0].irq;
	172	vrtc_resources[1].end = sfi_mrtc_array[0].irq;
	173
5ca9afdb	174	return platform_device_register(&vrtc_device);
0146f261 FT	175	}
	176
	177	module_init(mrst_device_create);