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

/*
 * An I2C driver for the PCF85063 RTC
 * Copyright 2014 Rose Technology
 *
 * Author: Søren Andersen <san@rosetechnology.dk>
 * Maintainers: http://www.nslu2-linux.org/
 *
 * based on the other drivers in this same directory.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <linux/i2c.h>
#include <linux/bcd.h>
#include <linux/rtc.h>
#include <linux/module.h>

#define PCF85063_REG_CTRL1		0x00 /* status */
#define PCF85063_REG_CTRL1_STOP		BIT(5)
#define PCF85063_REG_CTRL2		0x01

#define PCF85063_REG_SC			0x04 /* datetime */
#define PCF85063_REG_SC_OS		0x80
#define PCF85063_REG_MN			0x05
#define PCF85063_REG_HR			0x06
#define PCF85063_REG_DM			0x07
#define PCF85063_REG_DW			0x08
#define PCF85063_REG_MO			0x09
#define PCF85063_REG_YR			0x0A

static struct i2c_driver pcf85063_driver;

static int pcf85063_stop_clock(struct i2c_client *client, u8 *ctrl1)
{
	s32 ret;

	ret = i2c_smbus_read_byte_data(client, PCF85063_REG_CTRL1);
	if (ret < 0) {
		dev_err(&client->dev, "Failing to stop the clock\n");
		return -EIO;
	}

	/* stop the clock */
	ret |= PCF85063_REG_CTRL1_STOP;

	ret = i2c_smbus_write_byte_data(client, PCF85063_REG_CTRL1, ret);
	if (ret < 0) {
		dev_err(&client->dev, "Failing to stop the clock\n");
		return -EIO;
	}

	*ctrl1 = ret;

	return 0;
}

/*
 * In the routines that deal directly with the pcf85063 hardware, we use
 * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
 */
static int pcf85063_get_datetime(struct i2c_client *client, struct rtc_time *tm)
{
	int rc;
	u8 regs[7];

	/*
	 * while reading, the time/date registers are blocked and not updated
	 * anymore until the access is finished. To not lose a second
	 * event, the access must be finished within one second. So, read all
	 * time/date registers in one turn.
	 */
	rc = i2c_smbus_read_i2c_block_data(client, PCF85063_REG_SC,
					   sizeof(regs), regs);
	if (rc != sizeof(regs)) {
		dev_err(&client->dev, "date/time register read error\n");
		return -EIO;
	}

	/* if the clock has lost its power it makes no sense to use its time */
	if (regs[0] & PCF85063_REG_SC_OS) {
		dev_warn(&client->dev, "Power loss detected, invalid time\n");
		return -EINVAL;
	}

	tm->tm_sec = bcd2bin(regs[0] & 0x7F);
	tm->tm_min = bcd2bin(regs[1] & 0x7F);
	tm->tm_hour = bcd2bin(regs[2] & 0x3F); /* rtc hr 0-23 */
	tm->tm_mday = bcd2bin(regs[3] & 0x3F);
	tm->tm_wday = regs[4] & 0x07;
	tm->tm_mon = bcd2bin(regs[5] & 0x1F) - 1; /* rtc mn 1-12 */
	tm->tm_year = bcd2bin(regs[6]);
	if (tm->tm_year < 70)
		tm->tm_year += 100;	/* assume we are in 1970...2069 */

	return rtc_valid_tm(tm);
}

static int pcf85063_set_datetime(struct i2c_client *client, struct rtc_time *tm)
{
	int rc;
	u8 regs[8];

	/*
	 * to accurately set the time, reset the divider chain and keep it in
	 * reset state until all time/date registers are written
	 */
	rc = pcf85063_stop_clock(client, &regs[7]);
	if (rc != 0)
		return rc;

	/* hours, minutes and seconds */
	regs[0] = bin2bcd(tm->tm_sec) & 0x7F; /* clear OS flag */

	regs[1] = bin2bcd(tm->tm_min);
	regs[2] = bin2bcd(tm->tm_hour);

	/* Day of month, 1 - 31 */
	regs[3] = bin2bcd(tm->tm_mday);

	/* Day, 0 - 6 */
	regs[4] = tm->tm_wday & 0x07;

	/* month, 1 - 12 */
	regs[5] = bin2bcd(tm->tm_mon + 1);

	/* year and century */
	regs[6] = bin2bcd(tm->tm_year % 100);

	/*
	 * after all time/date registers are written, let the 'address auto
	 * increment' feature wrap around and write register CTRL1 to re-enable
	 * the clock divider chain again
	 */
	regs[7] &= ~PCF85063_REG_CTRL1_STOP;

	/* write all registers at once */
	rc = i2c_smbus_write_i2c_block_data(client, PCF85063_REG_SC,
					    sizeof(regs), regs);
	if (rc < 0) {
		dev_err(&client->dev, "date/time register write error\n");
		return rc;
	}

	return 0;
}

static int pcf85063_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	return pcf85063_get_datetime(to_i2c_client(dev), tm);
}

static int pcf85063_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	return pcf85063_set_datetime(to_i2c_client(dev), tm);
}

static const struct rtc_class_ops pcf85063_rtc_ops = {
	.read_time	= pcf85063_rtc_read_time,
	.set_time	= pcf85063_rtc_set_time
};

static int pcf85063_probe(struct i2c_client *client,
				const struct i2c_device_id *id)
{
	struct rtc_device *rtc;

	dev_dbg(&client->dev, "%s\n", __func__);

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
		return -ENODEV;

	rtc = devm_rtc_device_register(&client->dev,
				       pcf85063_driver.driver.name,
				       &pcf85063_rtc_ops, THIS_MODULE);

	return PTR_ERR_OR_ZERO(rtc);
}

static const struct i2c_device_id pcf85063_id[] = {
	{ "pcf85063", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, pcf85063_id);

#ifdef CONFIG_OF
static const struct of_device_id pcf85063_of_match[] = {
	{ .compatible = "nxp,pcf85063" },
	{}
};
MODULE_DEVICE_TABLE(of, pcf85063_of_match);
#endif

static struct i2c_driver pcf85063_driver = {
	.driver		= {
		.name	= "rtc-pcf85063",
		.of_match_table = of_match_ptr(pcf85063_of_match),
	},
	.probe		= pcf85063_probe,
	.id_table	= pcf85063_id,
};

module_i2c_driver(pcf85063_driver);

MODULE_AUTHOR("Søren Andersen <san@rosetechnology.dk>");
MODULE_DESCRIPTION("PCF85063 RTC driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
796b7abb SA	1	/*
	2	* An I2C driver for the PCF85063 RTC
	3	* Copyright 2014 Rose Technology
	4	*
	5	* Author: Søren Andersen <san@rosetechnology.dk>
	6	* Maintainers: http://www.nslu2-linux.org/
	7	*
	8	* based on the other drivers in this same directory.
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*/
	14	#include <linux/i2c.h>
	15	#include <linux/bcd.h>
	16	#include <linux/rtc.h>
	17	#include <linux/module.h>
	18
796b7abb	19	#define PCF85063_REG_CTRL1 0x00 /* status */
31d4d33e	20	#define PCF85063_REG_CTRL1_STOP BIT(5)
796b7abb SA	21	#define PCF85063_REG_CTRL2 0x01
	22
	23	#define PCF85063_REG_SC 0x04 /* datetime */
6cc4c8b1	24	#define PCF85063_REG_SC_OS 0x80
796b7abb SA	25	#define PCF85063_REG_MN 0x05
	26	#define PCF85063_REG_HR 0x06
	27	#define PCF85063_REG_DM 0x07
	28	#define PCF85063_REG_DW 0x08
	29	#define PCF85063_REG_MO 0x09
	30	#define PCF85063_REG_YR 0x0A
	31
796b7abb SA	32	static struct i2c_driver pcf85063_driver;
796b7abb SA	33
31d4d33e JB	34	static int pcf85063_stop_clock(struct i2c_client client, u8 ctrl1)
	35	{
	36	s32 ret;
	37
	38	ret = i2c_smbus_read_byte_data(client, PCF85063_REG_CTRL1);
	39	if (ret < 0) {
	40	dev_err(&client->dev, "Failing to stop the clock\n");
	41	return -EIO;
	42	}
	43
	44	/* stop the clock */
	45	ret \|= PCF85063_REG_CTRL1_STOP;
	46
	47	ret = i2c_smbus_write_byte_data(client, PCF85063_REG_CTRL1, ret);
	48	if (ret < 0) {
	49	dev_err(&client->dev, "Failing to stop the clock\n");
	50	return -EIO;
	51	}
	52
	53	*ctrl1 = ret;
	54
	55	return 0;
	56	}
	57
796b7abb SA	58	/*
	59	* In the routines that deal directly with the pcf85063 hardware, we use
	60	* rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
	61	*/
	62	static int pcf85063_get_datetime(struct i2c_client client, struct rtc_time tm)
	63	{
7b576848	64	int rc;
7b576848 JB	65	u8 regs[7];
	66
	67	/*
	68	* while reading, the time/date registers are blocked and not updated
	69	* anymore until the access is finished. To not lose a second
	70	* event, the access must be finished within one second. So, read all
	71	* time/date registers in one turn.
	72	*/
	73	rc = i2c_smbus_read_i2c_block_data(client, PCF85063_REG_SC,
	74	sizeof(regs), regs);
	75	if (rc != sizeof(regs)) {
	76	dev_err(&client->dev, "date/time register read error\n");
796b7abb SA	77	return -EIO;
	78	}
	79
6cc4c8b1 JB	80	/* if the clock has lost its power it makes no sense to use its time */
	81	if (regs[0] & PCF85063_REG_SC_OS) {
	82	dev_warn(&client->dev, "Power loss detected, invalid time\n");
	83	return -EINVAL;
	84	}
	85
7b576848 JB	86	tm->tm_sec = bcd2bin(regs[0] & 0x7F);
	87	tm->tm_min = bcd2bin(regs[1] & 0x7F);
	88	tm->tm_hour = bcd2bin(regs[2] & 0x3F); /* rtc hr 0-23 */
	89	tm->tm_mday = bcd2bin(regs[3] & 0x3F);
	90	tm->tm_wday = regs[4] & 0x07;
	91	tm->tm_mon = bcd2bin(regs[5] & 0x1F) - 1; /* rtc mn 1-12 */
	92	tm->tm_year = bcd2bin(regs[6]);
796b7abb SA	93	if (tm->tm_year < 70)
796b7abb SA	94	tm->tm_year += 100; /* assume we are in 1970...2069 */
796b7abb	95
5413eaba	96	return rtc_valid_tm(tm);
796b7abb SA	97	}
	98
	99	static int pcf85063_set_datetime(struct i2c_client client, struct rtc_time tm)
	100	{
31d4d33e JB	101	int rc;
31d4d33e JB	102	u8 regs[8];
796b7abb	103
31d4d33e JB	104	/*
	105	* to accurately set the time, reset the divider chain and keep it in
	106	* reset state until all time/date registers are written
	107	*/
	108	rc = pcf85063_stop_clock(client, &regs[7]);
	109	if (rc != 0)
	110	return rc;
796b7abb SA	111
796b7abb SA	112	/* hours, minutes and seconds */
31d4d33e	113	regs[0] = bin2bcd(tm->tm_sec) & 0x7F; /* clear OS flag */
796b7abb	114
31d4d33e JB	115	regs[1] = bin2bcd(tm->tm_min);
31d4d33e JB	116	regs[2] = bin2bcd(tm->tm_hour);
796b7abb SA	117
796b7abb SA	118	/* Day of month, 1 - 31 */
31d4d33e	119	regs[3] = bin2bcd(tm->tm_mday);
796b7abb SA	120
796b7abb SA	121	/* Day, 0 - 6 */
31d4d33e	122	regs[4] = tm->tm_wday & 0x07;
796b7abb SA	123
796b7abb SA	124	/* month, 1 - 12 */
31d4d33e	125	regs[5] = bin2bcd(tm->tm_mon + 1);
796b7abb SA	126
796b7abb SA	127	/* year and century */
31d4d33e JB	128	regs[6] = bin2bcd(tm->tm_year % 100);
	129
	130	/*
	131	* after all time/date registers are written, let the 'address auto
	132	* increment' feature wrap around and write register CTRL1 to re-enable
	133	* the clock divider chain again
	134	*/
	135	regs[7] &= ~PCF85063_REG_CTRL1_STOP;
	136
	137	/* write all registers at once */
	138	rc = i2c_smbus_write_i2c_block_data(client, PCF85063_REG_SC,
	139	sizeof(regs), regs);
	140	if (rc < 0) {
	141	dev_err(&client->dev, "date/time register write error\n");
	142	return rc;
796b7abb SA	143	}
	144
	145	return 0;
	146	}
	147
	148	static int pcf85063_rtc_read_time(struct device dev, struct rtc_time tm)
	149	{
	150	return pcf85063_get_datetime(to_i2c_client(dev), tm);
	151	}
	152
	153	static int pcf85063_rtc_set_time(struct device dev, struct rtc_time tm)
	154	{
	155	return pcf85063_set_datetime(to_i2c_client(dev), tm);
	156	}
	157
	158	static const struct rtc_class_ops pcf85063_rtc_ops = {
	159	.read_time = pcf85063_rtc_read_time,
	160	.set_time = pcf85063_rtc_set_time
	161	};
	162
	163	static int pcf85063_probe(struct i2c_client *client,
	164	const struct i2c_device_id *id)
	165	{
2da424af	166	struct rtc_device *rtc;
796b7abb SA	167
	168	dev_dbg(&client->dev, "%s\n", __func__);
	169
	170	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
	171	return -ENODEV;
	172
2da424af AB	173	rtc = devm_rtc_device_register(&client->dev,
	174	pcf85063_driver.driver.name,
	175	&pcf85063_rtc_ops, THIS_MODULE);
796b7abb	176
2da424af	177	return PTR_ERR_OR_ZERO(rtc);
796b7abb SA	178	}
	179
	180	static const struct i2c_device_id pcf85063_id[] = {
	181	{ "pcf85063", 0 },
	182	{ }
	183	};
	184	MODULE_DEVICE_TABLE(i2c, pcf85063_id);
	185
	186	#ifdef CONFIG_OF
	187	static const struct of_device_id pcf85063_of_match[] = {
	188	{ .compatible = "nxp,pcf85063" },
	189	{}
	190	};
	191	MODULE_DEVICE_TABLE(of, pcf85063_of_match);
	192	#endif
	193
	194	static struct i2c_driver pcf85063_driver = {
	195	.driver = {
	196	.name = "rtc-pcf85063",
796b7abb SA	197	.of_match_table = of_match_ptr(pcf85063_of_match),
	198	},
	199	.probe = pcf85063_probe,
	200	.id_table = pcf85063_id,
	201	};
	202
	203	module_i2c_driver(pcf85063_driver);
	204
	205	MODULE_AUTHOR("Søren Andersen <san@rosetechnology.dk>");
	206	MODULE_DESCRIPTION("PCF85063 RTC driver");
	207	MODULE_LICENSE("GPL");