[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / rtc / rtc-tile.c

/*
 * Copyright 2011 Tilera Corporation. All Rights Reserved.
 *
 *   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.
 *
 *   This program is distributed in the hope that it will be useful, but
 *   WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 *   NON INFRINGEMENT.  See the GNU General Public License for
 *   more details.
 *
 * Tilera-specific RTC driver.
 */

#include <linux/module.h>
#include <linux/device.h>
#include <linux/rtc.h>
#include <linux/platform_device.h>

/* Platform device pointer. */
static struct platform_device *tile_rtc_platform_device;

/*
 * RTC read routine.  Gets time info from RTC chip via hypervisor syscall.
 */
static int read_rtc_time(struct device *dev, struct rtc_time *tm)
{
	HV_RTCTime hvtm = hv_get_rtc();

	tm->tm_sec = hvtm.tm_sec;
	tm->tm_min = hvtm.tm_min;
	tm->tm_hour = hvtm.tm_hour;
	tm->tm_mday = hvtm.tm_mday;
	tm->tm_mon = hvtm.tm_mon;
	tm->tm_year = hvtm.tm_year;
	tm->tm_wday = 0;
	tm->tm_yday = 0;
	tm->tm_isdst = 0;

	if (rtc_valid_tm(tm) < 0)
		dev_warn(dev, "Read invalid date/time from RTC\n");

	return 0;
}

/*
 * RTC write routine.  Sends time info to hypervisor via syscall, to be
 * written to RTC chip.
 */
static int set_rtc_time(struct device *dev, struct rtc_time *tm)
{
	HV_RTCTime hvtm;

	hvtm.tm_sec = tm->tm_sec;
	hvtm.tm_min = tm->tm_min;
	hvtm.tm_hour = tm->tm_hour;
	hvtm.tm_mday = tm->tm_mday;
	hvtm.tm_mon = tm->tm_mon;
	hvtm.tm_year = tm->tm_year;

	hv_set_rtc(hvtm);

	return 0;
}

/*
 * RTC read/write ops.
 */
static const struct rtc_class_ops tile_rtc_ops = {
	.read_time	= read_rtc_time,
	.set_time	= set_rtc_time,
};

/*
 * Device probe routine.
 */
static int tile_rtc_probe(struct platform_device *dev)
{
	struct rtc_device *rtc;

	rtc = devm_rtc_device_register(&dev->dev, "tile",
				&tile_rtc_ops, THIS_MODULE);

	if (IS_ERR(rtc))
		return PTR_ERR(rtc);

	platform_set_drvdata(dev, rtc);

	return 0;
}

/*
 * Device cleanup routine.
 */
static int tile_rtc_remove(struct platform_device *dev)
{
	platform_set_drvdata(dev, NULL);

	return 0;
}

static struct platform_driver tile_rtc_platform_driver = {
	.driver		= {
		.name	= "rtc-tile",
		.owner	= THIS_MODULE,
	},
	.probe		= tile_rtc_probe,
	.remove		= tile_rtc_remove,
};

/*
 * Driver init routine.
 */
static int __init tile_rtc_driver_init(void)
{
	int err;

	err = platform_driver_register(&tile_rtc_platform_driver);
	if (err)
		return err;

	tile_rtc_platform_device = platform_device_alloc("rtc-tile", 0);
	if (tile_rtc_platform_device == NULL) {
		err = -ENOMEM;
		goto exit_driver_unregister;
	}

	err = platform_device_add(tile_rtc_platform_device);
	if (err)
		goto exit_device_put;

	return 0;

exit_device_put:
	platform_device_put(tile_rtc_platform_device);

exit_driver_unregister:
	platform_driver_unregister(&tile_rtc_platform_driver);
	return err;
}

/*
 * Driver cleanup routine.
 */
static void __exit tile_rtc_driver_exit(void)
{
	platform_device_unregister(tile_rtc_platform_device);
	platform_driver_unregister(&tile_rtc_platform_driver);
}

module_init(tile_rtc_driver_init);
module_exit(tile_rtc_driver_exit);

MODULE_DESCRIPTION("Tilera-specific Real Time Clock Driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:rtc-tile");
Commit	Line	Data
dd196a2b CM	1	/*
	2	* Copyright 2011 Tilera Corporation. All Rights Reserved.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation, version 2.
	7	*
	8	* This program is distributed in the hope that it will be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
	11	* NON INFRINGEMENT. See the GNU General Public License for
	12	* more details.
	13	*
	14	* Tilera-specific RTC driver.
	15	*/
	16
	17	#include <linux/module.h>
	18	#include <linux/device.h>
	19	#include <linux/rtc.h>
	20	#include <linux/platform_device.h>
	21
	22	/* Platform device pointer. */
	23	static struct platform_device *tile_rtc_platform_device;
	24
	25	/*
	26	* RTC read routine. Gets time info from RTC chip via hypervisor syscall.
	27	*/
	28	static int read_rtc_time(struct device dev, struct rtc_time tm)
	29	{
	30	HV_RTCTime hvtm = hv_get_rtc();
	31
	32	tm->tm_sec = hvtm.tm_sec;
	33	tm->tm_min = hvtm.tm_min;
	34	tm->tm_hour = hvtm.tm_hour;
	35	tm->tm_mday = hvtm.tm_mday;
	36	tm->tm_mon = hvtm.tm_mon;
	37	tm->tm_year = hvtm.tm_year;
	38	tm->tm_wday = 0;
	39	tm->tm_yday = 0;
	40	tm->tm_isdst = 0;
	41
	42	if (rtc_valid_tm(tm) < 0)
	43	dev_warn(dev, "Read invalid date/time from RTC\n");
	44
	45	return 0;
	46	}
	47
	48	/*
	49	* RTC write routine. Sends time info to hypervisor via syscall, to be
	50	* written to RTC chip.
	51	*/
	52	static int set_rtc_time(struct device dev, struct rtc_time tm)
	53	{
	54	HV_RTCTime hvtm;
	55
	56	hvtm.tm_sec = tm->tm_sec;
	57	hvtm.tm_min = tm->tm_min;
	58	hvtm.tm_hour = tm->tm_hour;
	59	hvtm.tm_mday = tm->tm_mday;
	60	hvtm.tm_mon = tm->tm_mon;
	61	hvtm.tm_year = tm->tm_year;
	62
	63	hv_set_rtc(hvtm);
	64
65	return 0;
66	}
67
68	/*
69	* RTC read/write ops.
70	*/
71	static const struct rtc_class_ops tile_rtc_ops = {
72	.read_time = read_rtc_time,
73	.set_time = set_rtc_time,
74	};
75
76	/*
77	* Device probe routine.
78	*/
5a167f45	79	static int tile_rtc_probe(struct platform_device *dev)
dd196a2b CM	80	{
	81	struct rtc_device *rtc;
	82
3a30b26e JH	83	rtc = devm_rtc_device_register(&dev->dev, "tile",
3a30b26e JH	84	&tile_rtc_ops, THIS_MODULE);
dd196a2b CM	85
	86	if (IS_ERR(rtc))
	87	return PTR_ERR(rtc);
	88
	89	platform_set_drvdata(dev, rtc);
	90
	91	return 0;
	92	}
	93
	94	/*
	95	* Device cleanup routine.
	96	*/
5a167f45	97	static int tile_rtc_remove(struct platform_device *dev)
dd196a2b	98	{
dd196a2b CM	99	platform_set_drvdata(dev, NULL);
	100
	101	return 0;
	102	}
	103
	104	static struct platform_driver tile_rtc_platform_driver = {
	105	.driver = {
	106	.name = "rtc-tile",
	107	.owner = THIS_MODULE,
	108	},
	109	.probe = tile_rtc_probe,
5a167f45	110	.remove = tile_rtc_remove,
dd196a2b CM	111	};
	112
	113	/*
	114	* Driver init routine.
	115	*/
	116	static int __init tile_rtc_driver_init(void)
	117	{
	118	int err;
	119
	120	err = platform_driver_register(&tile_rtc_platform_driver);
	121	if (err)
	122	return err;
	123
	124	tile_rtc_platform_device = platform_device_alloc("rtc-tile", 0);
	125	if (tile_rtc_platform_device == NULL) {
	126	err = -ENOMEM;
	127	goto exit_driver_unregister;
	128	}
	129
	130	err = platform_device_add(tile_rtc_platform_device);
	131	if (err)
	132	goto exit_device_put;
	133
	134	return 0;
	135
	136	exit_device_put:
	137	platform_device_put(tile_rtc_platform_device);
	138
	139	exit_driver_unregister:
	140	platform_driver_unregister(&tile_rtc_platform_driver);
	141	return err;
	142	}
	143
	144	/*
	145	* Driver cleanup routine.
	146	*/
	147	static void __exit tile_rtc_driver_exit(void)
	148	{
52fbc779	149	platform_device_unregister(tile_rtc_platform_device);
dd196a2b CM	150	platform_driver_unregister(&tile_rtc_platform_driver);
	151	}
	152
	153	module_init(tile_rtc_driver_init);
	154	module_exit(tile_rtc_driver_exit);
	155
	156	MODULE_DESCRIPTION("Tilera-specific Real Time Clock Driver");
	157	MODULE_LICENSE("GPL");
	158	MODULE_ALIAS("platform:rtc-tile");