[linux-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>

/*
 * Information for this driver was pulled from the following datasheets.
 *
 *  http://www.nxp.com/documents/data_sheet/PCF85063A.pdf
 *  http://www.nxp.com/documents/data_sheet/PCF85063TP.pdf
 *
 *  PCF85063A -- Rev. 6 — 18 November 2015
 *  PCF85063TP -- Rev. 4 — 6 May 2015
*/

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

#define PCF85063_REG_SC			0x04 /* datetime */
#define PCF85063_REG_SC_OS		0x80

static struct i2c_driver pcf85063_driver;

static int pcf85063_stop_clock(struct i2c_client *client, u8 *ctrl1)
{
	int rc;
	u8 reg;

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

	/* stop the clock */
	reg = rc | PCF85063_REG_CTRL1_STOP;

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

	*ctrl1 = reg;

	return 0;
}

static int pcf85063_start_clock(struct i2c_client *client, u8 ctrl1)
{
	int rc;

	/* start the clock */
	ctrl1 &= ~PCF85063_REG_CTRL1_STOP;

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

	return 0;
}

static int pcf85063_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct i2c_client *client = to_i2c_client(dev);
	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]);
	tm->tm_year += 100;

	return 0;
}

static int pcf85063_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct i2c_client *client = to_i2c_client(dev);
	int rc;
	u8 regs[7];
	u8 ctrl1;

	if ((tm->tm_year < 100) || (tm->tm_year > 199))
		return -EINVAL;

	/*
	 * 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, &ctrl1);
	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);

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

	/*
	 * Write the control register as a separate action since the size of
	 * the register space is different between the PCF85063TP and
	 * PCF85063A devices.  The rollover point can not be used.
	 */
	rc = pcf85063_start_clock(client, ctrl1);
	if (rc != 0)
		return rc;

	return 0;
}

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

static int pcf85063_load_capacitance(struct i2c_client *client)
{
	u32 load;
	int rc;
	u8 reg;

	rc = i2c_smbus_read_byte_data(client, PCF85063_REG_CTRL1);
	if (rc < 0)
		return rc;

	reg = rc;
	load = 7000;
	of_property_read_u32(client->dev.of_node, "quartz-load-femtofarads",
			     &load);

	switch (load) {
	default:
		dev_warn(&client->dev, "Unknown quartz-load-femtofarads value: %d. Assuming 7000",
			 load);
		/* fall through */
	case 7000:
		reg &= ~PCF85063_REG_CTRL1_CAP_SEL;
		break;
	case 12500:
		reg |= PCF85063_REG_CTRL1_CAP_SEL;
		break;
	}

	rc = i2c_smbus_write_byte_data(client, PCF85063_REG_CTRL1, reg);

	return rc;
}

static int pcf85063_probe(struct i2c_client *client)
{
	struct rtc_device *rtc;
	int err;

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

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

	err = i2c_smbus_read_byte_data(client, PCF85063_REG_CTRL1);
	if (err < 0) {
		dev_err(&client->dev, "RTC chip is not present\n");
		return err;
	}

	err = pcf85063_load_capacitance(client);
	if (err < 0)
		dev_warn(&client->dev, "failed to set xtal load capacitance: %d",
			 err);

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

	return PTR_ERR_OR_ZERO(rtc);
}

#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_new	= pcf85063_probe,
};

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
0d981f81 CD	19	/*
	20	* Information for this driver was pulled from the following datasheets.
	21	*
	22	* http://www.nxp.com/documents/data_sheet/PCF85063A.pdf
	23	* http://www.nxp.com/documents/data_sheet/PCF85063TP.pdf
	24	*
	25	* PCF85063A -- Rev. 6 — 18 November 2015
	26	* PCF85063TP -- Rev. 4 — 6 May 2015
	27	*/
	28
796b7abb	29	#define PCF85063_REG_CTRL1 0x00 /* status */
bbb43838	30	#define PCF85063_REG_CTRL1_CAP_SEL BIT(0)
31d4d33e	31	#define PCF85063_REG_CTRL1_STOP BIT(5)
796b7abb SA	32
796b7abb SA	33	#define PCF85063_REG_SC 0x04 /* datetime */
6cc4c8b1	34	#define PCF85063_REG_SC_OS 0x80
796b7abb	35
796b7abb SA	36	static struct i2c_driver pcf85063_driver;
796b7abb SA	37
31d4d33e JB	38	static int pcf85063_stop_clock(struct i2c_client client, u8 ctrl1)
31d4d33e JB	39	{
ec9cf1b7 AŠ	40	int rc;
ec9cf1b7 AŠ	41	u8 reg;
31d4d33e	42
ec9cf1b7 AŠ	43	rc = i2c_smbus_read_byte_data(client, PCF85063_REG_CTRL1);
ec9cf1b7 AŠ	44	if (rc < 0) {
31d4d33e JB	45	dev_err(&client->dev, "Failing to stop the clock\n");
	46	return -EIO;
	47	}
	48
	49	/* stop the clock */
ec9cf1b7	50	reg = rc \| PCF85063_REG_CTRL1_STOP;
31d4d33e	51
ec9cf1b7 AŠ	52	rc = i2c_smbus_write_byte_data(client, PCF85063_REG_CTRL1, reg);
ec9cf1b7 AŠ	53	if (rc < 0) {
31d4d33e JB	54	dev_err(&client->dev, "Failing to stop the clock\n");
	55	return -EIO;
	56	}
	57
ec9cf1b7	58	*ctrl1 = reg;
31d4d33e JB	59
	60	return 0;
	61	}
	62
0d981f81 CD	63	static int pcf85063_start_clock(struct i2c_client *client, u8 ctrl1)
0d981f81 CD	64	{
ec9cf1b7	65	int rc;
0d981f81 CD	66
0d981f81 CD	67	/* start the clock */
051abf55	68	ctrl1 &= ~PCF85063_REG_CTRL1_STOP;
0d981f81	69
ec9cf1b7 AŠ	70	rc = i2c_smbus_write_byte_data(client, PCF85063_REG_CTRL1, ctrl1);
ec9cf1b7 AŠ	71	if (rc < 0) {
0d981f81 CD	72	dev_err(&client->dev, "Failing to start the clock\n");
	73	return -EIO;
	74	}
	75
	76	return 0;
	77	}
	78
965271df	79	static int pcf85063_rtc_read_time(struct device dev, struct rtc_time tm)
796b7abb	80	{
965271df	81	struct i2c_client *client = to_i2c_client(dev);
7b576848	82	int rc;
7b576848 JB	83	u8 regs[7];
	84
	85	/*
	86	* while reading, the time/date registers are blocked and not updated
	87	* anymore until the access is finished. To not lose a second
	88	* event, the access must be finished within one second. So, read all
	89	* time/date registers in one turn.
	90	*/
	91	rc = i2c_smbus_read_i2c_block_data(client, PCF85063_REG_SC,
	92	sizeof(regs), regs);
	93	if (rc != sizeof(regs)) {
	94	dev_err(&client->dev, "date/time register read error\n");
796b7abb SA	95	return -EIO;
	96	}
	97
6cc4c8b1 JB	98	/* if the clock has lost its power it makes no sense to use its time */
	99	if (regs[0] & PCF85063_REG_SC_OS) {
	100	dev_warn(&client->dev, "Power loss detected, invalid time\n");
	101	return -EINVAL;
	102	}
	103
7b576848 JB	104	tm->tm_sec = bcd2bin(regs[0] & 0x7F);
	105	tm->tm_min = bcd2bin(regs[1] & 0x7F);
	106	tm->tm_hour = bcd2bin(regs[2] & 0x3F); /* rtc hr 0-23 */
	107	tm->tm_mday = bcd2bin(regs[3] & 0x3F);
	108	tm->tm_wday = regs[4] & 0x07;
	109	tm->tm_mon = bcd2bin(regs[5] & 0x1F) - 1; /* rtc mn 1-12 */
	110	tm->tm_year = bcd2bin(regs[6]);
c421ce72	111	tm->tm_year += 100;
796b7abb	112
0a6b8886	113	return 0;
796b7abb SA	114	}
796b7abb SA	115
965271df	116	static int pcf85063_rtc_set_time(struct device dev, struct rtc_time tm)
796b7abb	117	{
965271df	118	struct i2c_client *client = to_i2c_client(dev);
31d4d33e	119	int rc;
0d981f81 CD	120	u8 regs[7];
0d981f81 CD	121	u8 ctrl1;
796b7abb	122
c421ce72 AB	123	if ((tm->tm_year < 100) \|\| (tm->tm_year > 199))
	124	return -EINVAL;
	125
31d4d33e JB	126	/*
	127	* to accurately set the time, reset the divider chain and keep it in
	128	* reset state until all time/date registers are written
	129	*/
0d981f81	130	rc = pcf85063_stop_clock(client, &ctrl1);
31d4d33e JB	131	if (rc != 0)
31d4d33e JB	132	return rc;
796b7abb SA	133
796b7abb SA	134	/* hours, minutes and seconds */
31d4d33e	135	regs[0] = bin2bcd(tm->tm_sec) & 0x7F; /* clear OS flag */
796b7abb	136
31d4d33e JB	137	regs[1] = bin2bcd(tm->tm_min);
31d4d33e JB	138	regs[2] = bin2bcd(tm->tm_hour);
796b7abb SA	139
796b7abb SA	140	/* Day of month, 1 - 31 */
31d4d33e	141	regs[3] = bin2bcd(tm->tm_mday);
796b7abb SA	142
796b7abb SA	143	/* Day, 0 - 6 */
31d4d33e	144	regs[4] = tm->tm_wday & 0x07;
796b7abb SA	145
796b7abb SA	146	/* month, 1 - 12 */
31d4d33e	147	regs[5] = bin2bcd(tm->tm_mon + 1);
796b7abb SA	148
796b7abb SA	149	/* year and century */
c421ce72	150	regs[6] = bin2bcd(tm->tm_year - 100);
31d4d33e	151
31d4d33e JB	152	/* write all registers at once */
	153	rc = i2c_smbus_write_i2c_block_data(client, PCF85063_REG_SC,
	154	sizeof(regs), regs);
	155	if (rc < 0) {
	156	dev_err(&client->dev, "date/time register write error\n");
	157	return rc;
796b7abb SA	158	}
796b7abb SA	159
0d981f81 CD	160	/*
	161	* Write the control register as a separate action since the size of
	162	* the register space is different between the PCF85063TP and
	163	* PCF85063A devices. The rollover point can not be used.
	164	*/
	165	rc = pcf85063_start_clock(client, ctrl1);
	166	if (rc != 0)
	167	return rc;
	168
796b7abb SA	169	return 0;
	170	}
	171
796b7abb SA	172	static const struct rtc_class_ops pcf85063_rtc_ops = {
	173	.read_time = pcf85063_rtc_read_time,
	174	.set_time = pcf85063_rtc_set_time
	175	};
	176
bbb43838 SR	177	static int pcf85063_load_capacitance(struct i2c_client *client)
	178	{
	179	u32 load;
	180	int rc;
	181	u8 reg;
	182
	183	rc = i2c_smbus_read_byte_data(client, PCF85063_REG_CTRL1);
	184	if (rc < 0)
	185	return rc;
	186
	187	reg = rc;
	188	load = 7000;
	189	of_property_read_u32(client->dev.of_node, "quartz-load-femtofarads",
	190	&load);
	191
	192	switch (load) {
	193	default:
	194	dev_warn(&client->dev, "Unknown quartz-load-femtofarads value: %d. Assuming 7000",
	195	load);
	196	/* fall through */
	197	case 7000:
	198	reg &= ~PCF85063_REG_CTRL1_CAP_SEL;
	199	break;
	200	case 12500:
	201	reg \|= PCF85063_REG_CTRL1_CAP_SEL;
	202	break;
	203	}
	204
	205	rc = i2c_smbus_write_byte_data(client, PCF85063_REG_CTRL1, reg);
	206
	207	return rc;
	208	}
	209
0f21700a	210	static int pcf85063_probe(struct i2c_client *client)
796b7abb	211	{
2da424af	212	struct rtc_device *rtc;
c18b4c52	213	int err;
796b7abb SA	214
	215	dev_dbg(&client->dev, "%s\n", __func__);
	216
	217	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
	218	return -ENODEV;
	219
c18b4c52 MK	220	err = i2c_smbus_read_byte_data(client, PCF85063_REG_CTRL1);
	221	if (err < 0) {
	222	dev_err(&client->dev, "RTC chip is not present\n");
	223	return err;
	224	}
	225
bbb43838 SR	226	err = pcf85063_load_capacitance(client);
	227	if (err < 0)
	228	dev_warn(&client->dev, "failed to set xtal load capacitance: %d",
	229	err);
	230
2da424af AB	231	rtc = devm_rtc_device_register(&client->dev,
	232	pcf85063_driver.driver.name,
	233	&pcf85063_rtc_ops, THIS_MODULE);
796b7abb	234
2da424af	235	return PTR_ERR_OR_ZERO(rtc);
796b7abb SA	236	}
796b7abb SA	237
796b7abb SA	238	#ifdef CONFIG_OF
	239	static const struct of_device_id pcf85063_of_match[] = {
	240	{ .compatible = "nxp,pcf85063" },
	241	{}
	242	};
	243	MODULE_DEVICE_TABLE(of, pcf85063_of_match);
	244	#endif
	245
	246	static struct i2c_driver pcf85063_driver = {
	247	.driver = {
	248	.name = "rtc-pcf85063",
796b7abb SA	249	.of_match_table = of_match_ptr(pcf85063_of_match),
796b7abb SA	250	},
0f21700a	251	.probe_new = pcf85063_probe,
796b7abb SA	252	};
	253
	254	module_i2c_driver(pcf85063_driver);
	255
	256	MODULE_AUTHOR("Søren Andersen <san@rosetechnology.dk>");
	257	MODULE_DESCRIPTION("PCF85063 RTC driver");
	258	MODULE_LICENSE("GPL");