[deliverable/linux.git] / drivers / rtc / rtc-ds1216.c

/*
 * Dallas DS1216 RTC driver
 *
 * Copyright (c) 2007 Thomas Bogendoerfer
 *
 */

#include <linux/module.h>
#include <linux/rtc.h>
#include <linux/platform_device.h>
#include <linux/bcd.h>
#include <linux/slab.h>

#define DRV_VERSION "0.2"

struct ds1216_regs {
	u8 tsec;
	u8 sec;
	u8 min;
	u8 hour;
	u8 wday;
	u8 mday;
	u8 month;
	u8 year;
};

#define DS1216_HOUR_1224	(1 << 7)
#define DS1216_HOUR_AMPM	(1 << 5)

struct ds1216_priv {
	struct rtc_device *rtc;
	void __iomem *ioaddr;
};

static const u8 magic[] = {
	0xc5, 0x3a, 0xa3, 0x5c, 0xc5, 0x3a, 0xa3, 0x5c
};

/*
 * Read the 64 bit we'd like to have - It a series
 * of 64 bits showing up in the LSB of the base register.
 *
 */
static void ds1216_read(u8 __iomem *ioaddr, u8 *buf)
{
	unsigned char c;
	int i, j;

	for (i = 0; i < 8; i++) {
		c = 0;
		for (j = 0; j < 8; j++)
			c |= (readb(ioaddr) & 0x1) << j;
		buf[i] = c;
	}
}

static void ds1216_write(u8 __iomem *ioaddr, const u8 *buf)
{
	unsigned char c;
	int i, j;

	for (i = 0; i < 8; i++) {
		c = buf[i];
		for (j = 0; j < 8; j++) {
			writeb(c, ioaddr);
			c = c >> 1;
		}
	}
}

static void ds1216_switch_ds_to_clock(u8 __iomem *ioaddr)
{
	/* Reset magic pointer */
	readb(ioaddr);
	/* Write 64 bit magic to DS1216 */
	ds1216_write(ioaddr, magic);
}

static int ds1216_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct ds1216_priv *priv = platform_get_drvdata(pdev);
	struct ds1216_regs regs;

	ds1216_switch_ds_to_clock(priv->ioaddr);
	ds1216_read(priv->ioaddr, (u8 *)&regs);

	tm->tm_sec = bcd2bin(regs.sec);
	tm->tm_min = bcd2bin(regs.min);
	if (regs.hour & DS1216_HOUR_1224) {
		/* AM/PM mode */
		tm->tm_hour = bcd2bin(regs.hour & 0x1f);
		if (regs.hour & DS1216_HOUR_AMPM)
			tm->tm_hour += 12;
	} else
		tm->tm_hour = bcd2bin(regs.hour & 0x3f);
	tm->tm_wday = (regs.wday & 7) - 1;
	tm->tm_mday = bcd2bin(regs.mday & 0x3f);
	tm->tm_mon = bcd2bin(regs.month & 0x1f);
	tm->tm_year = bcd2bin(regs.year);
	if (tm->tm_year < 70)
		tm->tm_year += 100;

	return rtc_valid_tm(tm);
}

static int ds1216_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct ds1216_priv *priv = platform_get_drvdata(pdev);
	struct ds1216_regs regs;

	ds1216_switch_ds_to_clock(priv->ioaddr);
	ds1216_read(priv->ioaddr, (u8 *)&regs);

	regs.tsec = 0; /* clear 0.1 and 0.01 seconds */
	regs.sec = bin2bcd(tm->tm_sec);
	regs.min = bin2bcd(tm->tm_min);
	regs.hour &= DS1216_HOUR_1224;
	if (regs.hour && tm->tm_hour > 12) {
		regs.hour |= DS1216_HOUR_AMPM;
		tm->tm_hour -= 12;
	}
	regs.hour |= bin2bcd(tm->tm_hour);
	regs.wday &= ~7;
	regs.wday |= tm->tm_wday;
	regs.mday = bin2bcd(tm->tm_mday);
	regs.month = bin2bcd(tm->tm_mon);
	regs.year = bin2bcd(tm->tm_year % 100);

	ds1216_switch_ds_to_clock(priv->ioaddr);
	ds1216_write(priv->ioaddr, (u8 *)&regs);
	return 0;
}

static const struct rtc_class_ops ds1216_rtc_ops = {
	.read_time	= ds1216_rtc_read_time,
	.set_time	= ds1216_rtc_set_time,
};

static int __init ds1216_rtc_probe(struct platform_device *pdev)
{
	struct resource *res;
	struct ds1216_priv *priv;
	u8 dummy[8];

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res)
		return -ENODEV;
	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	platform_set_drvdata(pdev, priv);

	priv->ioaddr = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(priv->ioaddr))
		return PTR_ERR(priv->ioaddr);

	priv->rtc = devm_rtc_device_register(&pdev->dev, "ds1216",
					&ds1216_rtc_ops, THIS_MODULE);
	if (IS_ERR(priv->rtc))
		return PTR_ERR(priv->rtc);

	/* dummy read to get clock into a known state */
	ds1216_read(priv->ioaddr, dummy);
	return 0;
}

static struct platform_driver ds1216_rtc_platform_driver = {
	.driver		= {
		.name	= "rtc-ds1216",
		.owner	= THIS_MODULE,
	},
};

module_platform_driver_probe(ds1216_rtc_platform_driver, ds1216_rtc_probe);

MODULE_AUTHOR("Thomas Bogendoerfer <tsbogend@alpha.franken.de>");
MODULE_DESCRIPTION("DS1216 RTC driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);
MODULE_ALIAS("platform:rtc-ds1216");
Commit	Line	Data
537739de TB	1	/*
	2	* Dallas DS1216 RTC driver
	3	*
	4	* Copyright (c) 2007 Thomas Bogendoerfer
	5	*
	6	*/
	7
	8	#include <linux/module.h>
	9	#include <linux/rtc.h>
	10	#include <linux/platform_device.h>
	11	#include <linux/bcd.h>
5a0e3ad6	12	#include <linux/slab.h>
537739de	13
97a1f953	14	#define DRV_VERSION "0.2"
537739de TB	15
	16	struct ds1216_regs {
	17	u8 tsec;
	18	u8 sec;
	19	u8 min;
	20	u8 hour;
	21	u8 wday;
	22	u8 mday;
	23	u8 month;
	24	u8 year;
	25	};
	26
	27	#define DS1216_HOUR_1224 (1 << 7)
	28	#define DS1216_HOUR_AMPM (1 << 5)
	29
	30	struct ds1216_priv {
	31	struct rtc_device *rtc;
	32	void __iomem *ioaddr;
537739de TB	33	};
	34
	35	static const u8 magic[] = {
	36	0xc5, 0x3a, 0xa3, 0x5c, 0xc5, 0x3a, 0xa3, 0x5c
	37	};
	38
	39	/*
	40	* Read the 64 bit we'd like to have - It a series
	41	* of 64 bits showing up in the LSB of the base register.
	42	*
	43	*/
	44	static void ds1216_read(u8 __iomem ioaddr, u8 buf)
	45	{
	46	unsigned char c;
	47	int i, j;
	48
	49	for (i = 0; i < 8; i++) {
	50	c = 0;
	51	for (j = 0; j < 8; j++)
	52	c \|= (readb(ioaddr) & 0x1) << j;
	53	buf[i] = c;
	54	}
	55	}
	56
	57	static void ds1216_write(u8 __iomem ioaddr, const u8 buf)
	58	{
	59	unsigned char c;
	60	int i, j;
	61
	62	for (i = 0; i < 8; i++) {
	63	c = buf[i];
	64	for (j = 0; j < 8; j++) {
	65	writeb(c, ioaddr);
	66	c = c >> 1;
	67	}
	68	}
	69	}
	70
	71	static void ds1216_switch_ds_to_clock(u8 __iomem *ioaddr)
	72	{
	73	/* Reset magic pointer */
	74	readb(ioaddr);
	75	/* Write 64 bit magic to DS1216 */
	76	ds1216_write(ioaddr, magic);
	77	}
	78
	79	static int ds1216_rtc_read_time(struct device dev, struct rtc_time tm)
	80	{
	81	struct platform_device *pdev = to_platform_device(dev);
	82	struct ds1216_priv *priv = platform_get_drvdata(pdev);
	83	struct ds1216_regs regs;
	84
	85	ds1216_switch_ds_to_clock(priv->ioaddr);
	86	ds1216_read(priv->ioaddr, (u8 *)&regs);
	87
fe20ba70 AB	88	tm->tm_sec = bcd2bin(regs.sec);
fe20ba70 AB	89	tm->tm_min = bcd2bin(regs.min);
537739de TB	90	if (regs.hour & DS1216_HOUR_1224) {
537739de TB	91	/* AM/PM mode */
fe20ba70	92	tm->tm_hour = bcd2bin(regs.hour & 0x1f);
537739de TB	93	if (regs.hour & DS1216_HOUR_AMPM)
	94	tm->tm_hour += 12;
	95	} else
fe20ba70	96	tm->tm_hour = bcd2bin(regs.hour & 0x3f);
537739de	97	tm->tm_wday = (regs.wday & 7) - 1;
fe20ba70 AB	98	tm->tm_mday = bcd2bin(regs.mday & 0x3f);
	99	tm->tm_mon = bcd2bin(regs.month & 0x1f);
	100	tm->tm_year = bcd2bin(regs.year);
537739de TB	101	if (tm->tm_year < 70)
537739de TB	102	tm->tm_year += 100;
97a1f953 AZ	103
97a1f953 AZ	104	return rtc_valid_tm(tm);
537739de TB	105	}
	106
	107	static int ds1216_rtc_set_time(struct device dev, struct rtc_time tm)
	108	{
	109	struct platform_device *pdev = to_platform_device(dev);
	110	struct ds1216_priv *priv = platform_get_drvdata(pdev);
	111	struct ds1216_regs regs;
	112
	113	ds1216_switch_ds_to_clock(priv->ioaddr);
	114	ds1216_read(priv->ioaddr, (u8 *)&regs);
	115
	116	regs.tsec = 0; /* clear 0.1 and 0.01 seconds */
fe20ba70 AB	117	regs.sec = bin2bcd(tm->tm_sec);
fe20ba70 AB	118	regs.min = bin2bcd(tm->tm_min);
537739de TB	119	regs.hour &= DS1216_HOUR_1224;
	120	if (regs.hour && tm->tm_hour > 12) {
	121	regs.hour \|= DS1216_HOUR_AMPM;
	122	tm->tm_hour -= 12;
	123	}
fe20ba70	124	regs.hour \|= bin2bcd(tm->tm_hour);
537739de TB	125	regs.wday &= ~7;
537739de TB	126	regs.wday \|= tm->tm_wday;
fe20ba70 AB	127	regs.mday = bin2bcd(tm->tm_mday);
	128	regs.month = bin2bcd(tm->tm_mon);
	129	regs.year = bin2bcd(tm->tm_year % 100);
537739de TB	130
	131	ds1216_switch_ds_to_clock(priv->ioaddr);
	132	ds1216_write(priv->ioaddr, (u8 *)&regs);
	133	return 0;
	134	}
	135
	136	static const struct rtc_class_ops ds1216_rtc_ops = {
	137	.read_time = ds1216_rtc_read_time,
	138	.set_time = ds1216_rtc_set_time,
	139	};
	140
97a1f953	141	static int __init ds1216_rtc_probe(struct platform_device *pdev)
537739de	142	{
537739de TB	143	struct resource *res;
537739de TB	144	struct ds1216_priv *priv;
537739de TB	145	u8 dummy[8];
	146
	147	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	148	if (!res)
	149	return -ENODEV;
15c1567a	150	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
537739de TB	151	if (!priv)
537739de TB	152	return -ENOMEM;
97a1f953 AZ	153
	154	platform_set_drvdata(pdev, priv);
	155
15c1567a JH	156	priv->ioaddr = devm_ioremap_resource(&pdev->dev, res);
	157	if (IS_ERR(priv->ioaddr))
	158	return PTR_ERR(priv->ioaddr);
	159
	160	priv->rtc = devm_rtc_device_register(&pdev->dev, "ds1216",
	161	&ds1216_rtc_ops, THIS_MODULE);
	162	if (IS_ERR(priv->rtc))
	163	return PTR_ERR(priv->rtc);
537739de TB	164
	165	/* dummy read to get clock into a known state */
	166	ds1216_read(priv->ioaddr, dummy);
	167	return 0;
537739de TB	168	}
537739de TB	169
537739de TB	170	static struct platform_driver ds1216_rtc_platform_driver = {
	171	.driver = {
	172	.name = "rtc-ds1216",
	173	.owner = THIS_MODULE,
	174	},
537739de TB	175	};
537739de TB	176
061d2a3e	177	module_platform_driver_probe(ds1216_rtc_platform_driver, ds1216_rtc_probe);
537739de TB	178
	179	MODULE_AUTHOR("Thomas Bogendoerfer <tsbogend@alpha.franken.de>");
	180	MODULE_DESCRIPTION("DS1216 RTC driver");
	181	MODULE_LICENSE("GPL");
	182	MODULE_VERSION(DRV_VERSION);
ad28a07b	183	MODULE_ALIAS("platform:rtc-ds1216");