[mirror_ubuntu-bionic-kernel.git] / drivers / rtc / rtc-rv3029c2.c

/*
 * Micro Crystal RV-3029 rtc class driver
 *
 * Author: Gregory Hermant <gregory.hermant@calao-systems.com>
 *
 * based on previously existing rtc class drivers
 *
 * 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.
 *
 * NOTE: Currently this driver only supports the bare minimum for read
 * and write the RTC and alarms. The extra features provided by this chip
 * (trickle charger, eeprom, T° compensation) are unavailable.
 */

#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/bcd.h>
#include <linux/rtc.h>

/* Register map */
/* control section */
#define RV3029_ONOFF_CTRL		0x00
#define RV3029_ONOFF_CTRL_WE		BIT(0)
#define RV3029_ONOFF_CTRL_TE		BIT(1)
#define RV3029_ONOFF_CTRL_TAR		BIT(2)
#define RV3029_ONOFF_CTRL_EERE		BIT(3)
#define RV3029_ONOFF_CTRL_SRON		BIT(4)
#define RV3029_ONOFF_CTRL_TD0		BIT(5)
#define RV3029_ONOFF_CTRL_TD1		BIT(6)
#define RV3029_ONOFF_CTRL_CLKINT	BIT(7)
#define RV3029_IRQ_CTRL			0x01
#define RV3029_IRQ_CTRL_AIE		BIT(0)
#define RV3029_IRQ_CTRL_TIE		BIT(1)
#define RV3029_IRQ_CTRL_V1IE		BIT(2)
#define RV3029_IRQ_CTRL_V2IE		BIT(3)
#define RV3029_IRQ_CTRL_SRIE		BIT(4)
#define RV3029_IRQ_FLAGS		0x02
#define RV3029_IRQ_FLAGS_AF		BIT(0)
#define RV3029_IRQ_FLAGS_TF		BIT(1)
#define RV3029_IRQ_FLAGS_V1IF		BIT(2)
#define RV3029_IRQ_FLAGS_V2IF		BIT(3)
#define RV3029_IRQ_FLAGS_SRF		BIT(4)
#define RV3029_STATUS			0x03
#define RV3029_STATUS_VLOW1		BIT(2)
#define RV3029_STATUS_VLOW2		BIT(3)
#define RV3029_STATUS_SR		BIT(4)
#define RV3029_STATUS_PON		BIT(5)
#define RV3029_STATUS_EEBUSY		BIT(7)
#define RV3029_RST_CTRL			0x04
#define RV3029_RST_CTRL_SYSR		BIT(4)
#define RV3029_CONTROL_SECTION_LEN	0x05

/* watch section */
#define RV3029_W_SEC			0x08
#define RV3029_W_MINUTES		0x09
#define RV3029_W_HOURS			0x0A
#define RV3029_REG_HR_12_24		BIT(6) /* 24h/12h mode */
#define RV3029_REG_HR_PM		BIT(5) /* PM/AM bit in 12h mode */
#define RV3029_W_DATE			0x0B
#define RV3029_W_DAYS			0x0C
#define RV3029_W_MONTHS			0x0D
#define RV3029_W_YEARS			0x0E
#define RV3029_WATCH_SECTION_LEN	0x07

/* alarm section */
#define RV3029_A_SC			0x10
#define RV3029_A_MN			0x11
#define RV3029_A_HR			0x12
#define RV3029_A_DT			0x13
#define RV3029_A_DW			0x14
#define RV3029_A_MO			0x15
#define RV3029_A_YR			0x16
#define RV3029_ALARM_SECTION_LEN	0x07

/* timer section */
#define RV3029_TIMER_LOW		0x18
#define RV3029_TIMER_HIGH		0x19

/* temperature section */
#define RV3029_TEMP_PAGE		0x20

/* eeprom data section */
#define RV3029_E2P_EEDATA1		0x28
#define RV3029_E2P_EEDATA2		0x29
#define RV3029_E2PDATA_SECTION_LEN	0x02

/* eeprom control section */
#define RV3029_CONTROL_E2P_EECTRL	0x30
#define RV3029_EECTRL_THP		BIT(0) /* temp scan interval */
#define RV3029_EECTRL_THE		BIT(1) /* thermometer enable */
#define RV3029_EECTRL_FD0		BIT(2) /* CLKOUT */
#define RV3029_EECTRL_FD1		BIT(3) /* CLKOUT */
#define RV3029_TRICKLE_1K		BIT(4) /* 1.5K resistance */
#define RV3029_TRICKLE_5K		BIT(5) /* 5K   resistance */
#define RV3029_TRICKLE_20K		BIT(6) /* 20K  resistance */
#define RV3029_TRICKLE_80K		BIT(7) /* 80K  resistance */
#define RV3029_TRICKLE_MASK		(RV3029_TRICKLE_1K |\
					 RV3029_TRICKLE_5K |\
					 RV3029_TRICKLE_20K |\
					 RV3029_TRICKLE_80K)
#define RV3029_TRICKLE_SHIFT		4
#define RV3029_CONTROL_E2P_XOFFS	0x31 /* XTAL offset */
#define RV3029_CONTROL_E2P_XOFFS_SIGN	BIT(7) /* Sign: 1->pos, 0->neg */
#define RV3029_CONTROL_E2P_QCOEF	0x32 /* XTAL temp drift coef */
#define RV3029_CONTROL_E2P_TURNOVER	0x33 /* XTAL turnover temp (in *C) */
#define RV3029_CONTROL_E2P_TOV_MASK	0x3F /* XTAL turnover temp mask */

/* user ram section */
#define RV3029_USR1_RAM_PAGE		0x38
#define RV3029_USR1_SECTION_LEN		0x04
#define RV3029_USR2_RAM_PAGE		0x3C
#define RV3029_USR2_SECTION_LEN		0x04

static int
rv3029_i2c_read_regs(struct i2c_client *client, u8 reg, u8 *buf,
		     unsigned len)
{
	int ret;

	if ((reg > RV3029_USR1_RAM_PAGE + 7) ||
		(reg + len > RV3029_USR1_RAM_PAGE + 8))
		return -EINVAL;

	ret = i2c_smbus_read_i2c_block_data(client, reg, len, buf);
	if (ret < 0)
		return ret;
	if (ret < len)
		return -EIO;
	return 0;
}

static int
rv3029_i2c_write_regs(struct i2c_client *client, u8 reg, u8 const buf[],
		      unsigned len)
{
	if ((reg > RV3029_USR1_RAM_PAGE + 7) ||
		(reg + len > RV3029_USR1_RAM_PAGE + 8))
		return -EINVAL;

	return i2c_smbus_write_i2c_block_data(client, reg, len, buf);
}

static int
rv3029_i2c_get_sr(struct i2c_client *client, u8 *buf)
{
	int ret = rv3029_i2c_read_regs(client, RV3029_STATUS, buf, 1);

	if (ret < 0)
		return -EIO;
	dev_dbg(&client->dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
	return 0;
}

static int
rv3029_i2c_set_sr(struct i2c_client *client, u8 val)
{
	u8 buf[1];
	int sr;

	buf[0] = val;
	sr = rv3029_i2c_write_regs(client, RV3029_STATUS, buf, 1);
	dev_dbg(&client->dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
	if (sr < 0)
		return -EIO;
	return 0;
}

static int
rv3029_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
{
	u8 buf[1];
	int ret;
	u8 regs[RV3029_WATCH_SECTION_LEN] = { 0, };

	ret = rv3029_i2c_get_sr(client, buf);
	if (ret < 0) {
		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
		return -EIO;
	}

	ret = rv3029_i2c_read_regs(client, RV3029_W_SEC, regs,
				   RV3029_WATCH_SECTION_LEN);
	if (ret < 0) {
		dev_err(&client->dev, "%s: reading RTC section failed\n",
			__func__);
		return ret;
	}

	tm->tm_sec = bcd2bin(regs[RV3029_W_SEC-RV3029_W_SEC]);
	tm->tm_min = bcd2bin(regs[RV3029_W_MINUTES-RV3029_W_SEC]);

	/* HR field has a more complex interpretation */
	{
		const u8 _hr = regs[RV3029_W_HOURS-RV3029_W_SEC];

		if (_hr & RV3029_REG_HR_12_24) {
			/* 12h format */
			tm->tm_hour = bcd2bin(_hr & 0x1f);
			if (_hr & RV3029_REG_HR_PM)	/* PM flag set */
				tm->tm_hour += 12;
		} else /* 24h format */
			tm->tm_hour = bcd2bin(_hr & 0x3f);
	}

	tm->tm_mday = bcd2bin(regs[RV3029_W_DATE-RV3029_W_SEC]);
	tm->tm_mon = bcd2bin(regs[RV3029_W_MONTHS-RV3029_W_SEC]) - 1;
	tm->tm_year = bcd2bin(regs[RV3029_W_YEARS-RV3029_W_SEC]) + 100;
	tm->tm_wday = bcd2bin(regs[RV3029_W_DAYS-RV3029_W_SEC]) - 1;

	return 0;
}

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

static int
rv3029_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
{
	struct rtc_time *const tm = &alarm->time;
	int ret;
	u8 regs[8];

	ret = rv3029_i2c_get_sr(client, regs);
	if (ret < 0) {
		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
		return -EIO;
	}

	ret = rv3029_i2c_read_regs(client, RV3029_A_SC, regs,
				   RV3029_ALARM_SECTION_LEN);

	if (ret < 0) {
		dev_err(&client->dev, "%s: reading alarm section failed\n",
			__func__);
		return ret;
	}

	tm->tm_sec = bcd2bin(regs[RV3029_A_SC-RV3029_A_SC] & 0x7f);
	tm->tm_min = bcd2bin(regs[RV3029_A_MN-RV3029_A_SC] & 0x7f);
	tm->tm_hour = bcd2bin(regs[RV3029_A_HR-RV3029_A_SC] & 0x3f);
	tm->tm_mday = bcd2bin(regs[RV3029_A_DT-RV3029_A_SC] & 0x3f);
	tm->tm_mon = bcd2bin(regs[RV3029_A_MO-RV3029_A_SC] & 0x1f) - 1;
	tm->tm_year = bcd2bin(regs[RV3029_A_YR-RV3029_A_SC] & 0x7f) + 100;
	tm->tm_wday = bcd2bin(regs[RV3029_A_DW-RV3029_A_SC] & 0x07) - 1;

	return 0;
}

static int
rv3029_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	return rv3029_i2c_read_alarm(to_i2c_client(dev), alarm);
}

static int rv3029_rtc_i2c_alarm_set_irq(struct i2c_client *client,
					int enable)
{
	int ret;
	u8 buf[1];

	/* enable AIE irq */
	ret = rv3029_i2c_read_regs(client, RV3029_IRQ_CTRL, buf, 1);
	if (ret < 0) {
		dev_err(&client->dev, "can't read INT reg\n");
		return ret;
	}
	if (enable)
		buf[0] |= RV3029_IRQ_CTRL_AIE;
	else
		buf[0] &= ~RV3029_IRQ_CTRL_AIE;

	ret = rv3029_i2c_write_regs(client, RV3029_IRQ_CTRL, buf, 1);
	if (ret < 0) {
		dev_err(&client->dev, "can't set INT reg\n");
		return ret;
	}

	return 0;
}

static int rv3029_rtc_i2c_set_alarm(struct i2c_client *client,
				    struct rtc_wkalrm *alarm)
{
	struct rtc_time *const tm = &alarm->time;
	int ret;
	u8 regs[8];

	/*
	 * The clock has an 8 bit wide bcd-coded register (they never learn)
	 * for the year. tm_year is an offset from 1900 and we are interested
	 * in the 2000-2099 range, so any value less than 100 is invalid.
	*/
	if (tm->tm_year < 100)
		return -EINVAL;

	ret = rv3029_i2c_get_sr(client, regs);
	if (ret < 0) {
		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
		return -EIO;
	}
	regs[RV3029_A_SC-RV3029_A_SC] = bin2bcd(tm->tm_sec & 0x7f);
	regs[RV3029_A_MN-RV3029_A_SC] = bin2bcd(tm->tm_min & 0x7f);
	regs[RV3029_A_HR-RV3029_A_SC] = bin2bcd(tm->tm_hour & 0x3f);
	regs[RV3029_A_DT-RV3029_A_SC] = bin2bcd(tm->tm_mday & 0x3f);
	regs[RV3029_A_MO-RV3029_A_SC] = bin2bcd((tm->tm_mon & 0x1f) - 1);
	regs[RV3029_A_DW-RV3029_A_SC] = bin2bcd((tm->tm_wday & 7) - 1);
	regs[RV3029_A_YR-RV3029_A_SC] = bin2bcd((tm->tm_year & 0x7f) - 100);

	ret = rv3029_i2c_write_regs(client, RV3029_A_SC, regs,
				    RV3029_ALARM_SECTION_LEN);
	if (ret < 0)
		return ret;

	if (alarm->enabled) {
		u8 buf[1];

		/* clear AF flag */
		ret = rv3029_i2c_read_regs(client, RV3029_IRQ_FLAGS,
					   buf, 1);
		if (ret < 0) {
			dev_err(&client->dev, "can't read alarm flag\n");
			return ret;
		}
		buf[0] &= ~RV3029_IRQ_FLAGS_AF;
		ret = rv3029_i2c_write_regs(client, RV3029_IRQ_FLAGS,
					    buf, 1);
		if (ret < 0) {
			dev_err(&client->dev, "can't set alarm flag\n");
			return ret;
		}
		/* enable AIE irq */
		ret = rv3029_rtc_i2c_alarm_set_irq(client, 1);
		if (ret)
			return ret;

		dev_dbg(&client->dev, "alarm IRQ armed\n");
	} else {
		/* disable AIE irq */
		ret = rv3029_rtc_i2c_alarm_set_irq(client, 0);
		if (ret)
			return ret;

		dev_dbg(&client->dev, "alarm IRQ disabled\n");
	}

	return 0;
}

static int rv3029_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	return rv3029_rtc_i2c_set_alarm(to_i2c_client(dev), alarm);
}

static int
rv3029_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
{
	u8 regs[8];
	int ret;

	/*
	 * The clock has an 8 bit wide bcd-coded register (they never learn)
	 * for the year. tm_year is an offset from 1900 and we are interested
	 * in the 2000-2099 range, so any value less than 100 is invalid.
	*/
	if (tm->tm_year < 100)
		return -EINVAL;

	regs[RV3029_W_SEC-RV3029_W_SEC] = bin2bcd(tm->tm_sec);
	regs[RV3029_W_MINUTES-RV3029_W_SEC] = bin2bcd(tm->tm_min);
	regs[RV3029_W_HOURS-RV3029_W_SEC] = bin2bcd(tm->tm_hour);
	regs[RV3029_W_DATE-RV3029_W_SEC] = bin2bcd(tm->tm_mday);
	regs[RV3029_W_MONTHS-RV3029_W_SEC] = bin2bcd(tm->tm_mon+1);
	regs[RV3029_W_DAYS-RV3029_W_SEC] = bin2bcd((tm->tm_wday & 7)+1);
	regs[RV3029_W_YEARS-RV3029_W_SEC] = bin2bcd(tm->tm_year - 100);

	ret = rv3029_i2c_write_regs(client, RV3029_W_SEC, regs,
				    RV3029_WATCH_SECTION_LEN);
	if (ret < 0)
		return ret;

	ret = rv3029_i2c_get_sr(client, regs);
	if (ret < 0) {
		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
		return ret;
	}
	/* clear PON bit */
	ret = rv3029_i2c_set_sr(client, (regs[0] & ~RV3029_STATUS_PON));
	if (ret < 0) {
		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
		return ret;
	}

	return 0;
}

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

static const struct rtc_class_ops rv3029_rtc_ops = {
	.read_time	= rv3029_rtc_read_time,
	.set_time	= rv3029_rtc_set_time,
	.read_alarm	= rv3029_rtc_read_alarm,
	.set_alarm	= rv3029_rtc_set_alarm,
};

static struct i2c_device_id rv3029_id[] = {
	{ "rv3029", 0 },
	{ "rv3029c2", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, rv3029_id);

static int rv3029_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct rtc_device *rtc;
	int rc = 0;
	u8 buf[1];

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

	rc = rv3029_i2c_get_sr(client, buf);
	if (rc < 0) {
		dev_err(&client->dev, "reading status failed\n");
		return rc;
	}

	rtc = devm_rtc_device_register(&client->dev, client->name,
				       &rv3029_rtc_ops, THIS_MODULE);

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

	i2c_set_clientdata(client, rtc);

	return 0;
}

static struct i2c_driver rv3029_driver = {
	.driver = {
		.name = "rtc-rv3029c2",
	},
	.probe		= rv3029_probe,
	.id_table	= rv3029_id,
};

module_i2c_driver(rv3029_driver);

MODULE_AUTHOR("Gregory Hermant <gregory.hermant@calao-systems.com>");
MODULE_DESCRIPTION("Micro Crystal RV3029 RTC driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
52365230	1	/*
aba39d27	2	* Micro Crystal RV-3029 rtc class driver
52365230 HS	3	*
	4	* Author: Gregory Hermant <gregory.hermant@calao-systems.com>
	5	*
	6	* based on previously existing rtc class drivers
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
	12	* NOTE: Currently this driver only supports the bare minimum for read
	13	* and write the RTC and alarms. The extra features provided by this chip
	14	* (trickle charger, eeprom, T° compensation) are unavailable.
	15	*/
	16
	17	#include <linux/module.h>
	18	#include <linux/i2c.h>
	19	#include <linux/bcd.h>
	20	#include <linux/rtc.h>
	21
	22	/* Register map */
	23	/* control section */
aba39d27	24	#define RV3029_ONOFF_CTRL 0x00
7697de35 MB	25	#define RV3029_ONOFF_CTRL_WE BIT(0)
	26	#define RV3029_ONOFF_CTRL_TE BIT(1)
	27	#define RV3029_ONOFF_CTRL_TAR BIT(2)
	28	#define RV3029_ONOFF_CTRL_EERE BIT(3)
	29	#define RV3029_ONOFF_CTRL_SRON BIT(4)
	30	#define RV3029_ONOFF_CTRL_TD0 BIT(5)
	31	#define RV3029_ONOFF_CTRL_TD1 BIT(6)
	32	#define RV3029_ONOFF_CTRL_CLKINT BIT(7)
aba39d27	33	#define RV3029_IRQ_CTRL 0x01
7697de35 MB	34	#define RV3029_IRQ_CTRL_AIE BIT(0)
	35	#define RV3029_IRQ_CTRL_TIE BIT(1)
	36	#define RV3029_IRQ_CTRL_V1IE BIT(2)
	37	#define RV3029_IRQ_CTRL_V2IE BIT(3)
	38	#define RV3029_IRQ_CTRL_SRIE BIT(4)
aba39d27	39	#define RV3029_IRQ_FLAGS 0x02
7697de35 MB	40	#define RV3029_IRQ_FLAGS_AF BIT(0)
	41	#define RV3029_IRQ_FLAGS_TF BIT(1)
	42	#define RV3029_IRQ_FLAGS_V1IF BIT(2)
	43	#define RV3029_IRQ_FLAGS_V2IF BIT(3)
	44	#define RV3029_IRQ_FLAGS_SRF BIT(4)
aba39d27	45	#define RV3029_STATUS 0x03
7697de35 MB	46	#define RV3029_STATUS_VLOW1 BIT(2)
	47	#define RV3029_STATUS_VLOW2 BIT(3)
	48	#define RV3029_STATUS_SR BIT(4)
	49	#define RV3029_STATUS_PON BIT(5)
	50	#define RV3029_STATUS_EEBUSY BIT(7)
aba39d27	51	#define RV3029_RST_CTRL 0x04
7697de35	52	#define RV3029_RST_CTRL_SYSR BIT(4)
aba39d27	53	#define RV3029_CONTROL_SECTION_LEN 0x05
52365230 HS	54
52365230 HS	55	/* watch section */
aba39d27 MB	56	#define RV3029_W_SEC 0x08
	57	#define RV3029_W_MINUTES 0x09
	58	#define RV3029_W_HOURS 0x0A
7697de35 MB	59	#define RV3029_REG_HR_12_24 BIT(6) /* 24h/12h mode */
7697de35 MB	60	#define RV3029_REG_HR_PM BIT(5) /* PM/AM bit in 12h mode */
aba39d27 MB	61	#define RV3029_W_DATE 0x0B
	62	#define RV3029_W_DAYS 0x0C
	63	#define RV3029_W_MONTHS 0x0D
	64	#define RV3029_W_YEARS 0x0E
	65	#define RV3029_WATCH_SECTION_LEN 0x07
52365230 HS	66
52365230 HS	67	/* alarm section */
aba39d27 MB	68	#define RV3029_A_SC 0x10
	69	#define RV3029_A_MN 0x11
	70	#define RV3029_A_HR 0x12
	71	#define RV3029_A_DT 0x13
	72	#define RV3029_A_DW 0x14
	73	#define RV3029_A_MO 0x15
	74	#define RV3029_A_YR 0x16
	75	#define RV3029_ALARM_SECTION_LEN 0x07
52365230 HS	76
52365230 HS	77	/* timer section */
aba39d27 MB	78	#define RV3029_TIMER_LOW 0x18
aba39d27 MB	79	#define RV3029_TIMER_HIGH 0x19
52365230 HS	80
52365230 HS	81	/* temperature section */
aba39d27	82	#define RV3029_TEMP_PAGE 0x20
52365230 HS	83
52365230 HS	84	/* eeprom data section */
aba39d27 MB	85	#define RV3029_E2P_EEDATA1 0x28
aba39d27 MB	86	#define RV3029_E2P_EEDATA2 0x29
7697de35	87	#define RV3029_E2PDATA_SECTION_LEN 0x02
52365230 HS	88
52365230 HS	89	/* eeprom control section */
aba39d27	90	#define RV3029_CONTROL_E2P_EECTRL 0x30
7697de35 MB	91	#define RV3029_EECTRL_THP BIT(0) /* temp scan interval */
	92	#define RV3029_EECTRL_THE BIT(1) /* thermometer enable */
	93	#define RV3029_EECTRL_FD0 BIT(2) /* CLKOUT */
	94	#define RV3029_EECTRL_FD1 BIT(3) /* CLKOUT */
	95	#define RV3029_TRICKLE_1K BIT(4) /* 1.5K resistance */
	96	#define RV3029_TRICKLE_5K BIT(5) /* 5K resistance */
	97	#define RV3029_TRICKLE_20K BIT(6) /* 20K resistance */
	98	#define RV3029_TRICKLE_80K BIT(7) /* 80K resistance */
	99	#define RV3029_TRICKLE_MASK (RV3029_TRICKLE_1K \|\
	100	RV3029_TRICKLE_5K \|\
	101	RV3029_TRICKLE_20K \|\
	102	RV3029_TRICKLE_80K)
	103	#define RV3029_TRICKLE_SHIFT 4
	104	#define RV3029_CONTROL_E2P_XOFFS 0x31 /* XTAL offset */
	105	#define RV3029_CONTROL_E2P_XOFFS_SIGN BIT(7) /* Sign: 1->pos, 0->neg */
	106	#define RV3029_CONTROL_E2P_QCOEF 0x32 /* XTAL temp drift coef */
	107	#define RV3029_CONTROL_E2P_TURNOVER 0x33 /* XTAL turnover temp (in C) /
	108	#define RV3029_CONTROL_E2P_TOV_MASK 0x3F /* XTAL turnover temp mask */
52365230 HS	109
52365230 HS	110	/* user ram section */
aba39d27 MB	111	#define RV3029_USR1_RAM_PAGE 0x38
	112	#define RV3029_USR1_SECTION_LEN 0x04
	113	#define RV3029_USR2_RAM_PAGE 0x3C
	114	#define RV3029_USR2_SECTION_LEN 0x04
52365230 HS	115
52365230 HS	116	static int
aba39d27 MB	117	rv3029_i2c_read_regs(struct i2c_client client, u8 reg, u8 buf,
aba39d27 MB	118	unsigned len)
52365230 HS	119	{
	120	int ret;
	121
aba39d27 MB	122	if ((reg > RV3029_USR1_RAM_PAGE + 7) \|\|
aba39d27 MB	123	(reg + len > RV3029_USR1_RAM_PAGE + 8))
52365230 HS	124	return -EINVAL;
	125
	126	ret = i2c_smbus_read_i2c_block_data(client, reg, len, buf);
	127	if (ret < 0)
	128	return ret;
	129	if (ret < len)
	130	return -EIO;
	131	return 0;
	132	}
	133
	134	static int
aba39d27 MB	135	rv3029_i2c_write_regs(struct i2c_client *client, u8 reg, u8 const buf[],
aba39d27 MB	136	unsigned len)
52365230	137	{
aba39d27 MB	138	if ((reg > RV3029_USR1_RAM_PAGE + 7) \|\|
aba39d27 MB	139	(reg + len > RV3029_USR1_RAM_PAGE + 8))
52365230 HS	140	return -EINVAL;
	141
	142	return i2c_smbus_write_i2c_block_data(client, reg, len, buf);
	143	}
	144
	145	static int
aba39d27	146	rv3029_i2c_get_sr(struct i2c_client client, u8 buf)
52365230	147	{
aba39d27	148	int ret = rv3029_i2c_read_regs(client, RV3029_STATUS, buf, 1);
52365230 HS	149
	150	if (ret < 0)
	151	return -EIO;
	152	dev_dbg(&client->dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
	153	return 0;
	154	}
	155
	156	static int
aba39d27	157	rv3029_i2c_set_sr(struct i2c_client *client, u8 val)
52365230 HS	158	{
	159	u8 buf[1];
	160	int sr;
	161
	162	buf[0] = val;
aba39d27	163	sr = rv3029_i2c_write_regs(client, RV3029_STATUS, buf, 1);
52365230 HS	164	dev_dbg(&client->dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
	165	if (sr < 0)
	166	return -EIO;
	167	return 0;
	168	}
	169
	170	static int
aba39d27	171	rv3029_i2c_read_time(struct i2c_client client, struct rtc_time tm)
52365230 HS	172	{
	173	u8 buf[1];
	174	int ret;
aba39d27	175	u8 regs[RV3029_WATCH_SECTION_LEN] = { 0, };
52365230	176
aba39d27	177	ret = rv3029_i2c_get_sr(client, buf);
52365230 HS	178	if (ret < 0) {
	179	dev_err(&client->dev, "%s: reading SR failed\n", __func__);
	180	return -EIO;
	181	}
	182
aba39d27 MB	183	ret = rv3029_i2c_read_regs(client, RV3029_W_SEC, regs,
aba39d27 MB	184	RV3029_WATCH_SECTION_LEN);
52365230 HS	185	if (ret < 0) {
	186	dev_err(&client->dev, "%s: reading RTC section failed\n",
	187	__func__);
	188	return ret;
	189	}
	190
aba39d27 MB	191	tm->tm_sec = bcd2bin(regs[RV3029_W_SEC-RV3029_W_SEC]);
aba39d27 MB	192	tm->tm_min = bcd2bin(regs[RV3029_W_MINUTES-RV3029_W_SEC]);
52365230 HS	193
	194	/* HR field has a more complex interpretation */
	195	{
aba39d27 MB	196	const u8 _hr = regs[RV3029_W_HOURS-RV3029_W_SEC];
	197
	198	if (_hr & RV3029_REG_HR_12_24) {
52365230 HS	199	/* 12h format */
52365230 HS	200	tm->tm_hour = bcd2bin(_hr & 0x1f);
aba39d27	201	if (_hr & RV3029_REG_HR_PM) /* PM flag set */
52365230 HS	202	tm->tm_hour += 12;
	203	} else /* 24h format */
	204	tm->tm_hour = bcd2bin(_hr & 0x3f);
	205	}
	206
aba39d27 MB	207	tm->tm_mday = bcd2bin(regs[RV3029_W_DATE-RV3029_W_SEC]);
	208	tm->tm_mon = bcd2bin(regs[RV3029_W_MONTHS-RV3029_W_SEC]) - 1;
	209	tm->tm_year = bcd2bin(regs[RV3029_W_YEARS-RV3029_W_SEC]) + 100;
	210	tm->tm_wday = bcd2bin(regs[RV3029_W_DAYS-RV3029_W_SEC]) - 1;
52365230 HS	211
	212	return 0;
	213	}
	214
aba39d27	215	static int rv3029_rtc_read_time(struct device dev, struct rtc_time tm)
52365230	216	{
aba39d27	217	return rv3029_i2c_read_time(to_i2c_client(dev), tm);
52365230 HS	218	}
	219
	220	static int
aba39d27	221	rv3029_i2c_read_alarm(struct i2c_client client, struct rtc_wkalrm alarm)
52365230 HS	222	{
	223	struct rtc_time *const tm = &alarm->time;
	224	int ret;
	225	u8 regs[8];
	226
aba39d27	227	ret = rv3029_i2c_get_sr(client, regs);
52365230 HS	228	if (ret < 0) {
	229	dev_err(&client->dev, "%s: reading SR failed\n", __func__);
	230	return -EIO;
	231	}
	232
aba39d27 MB	233	ret = rv3029_i2c_read_regs(client, RV3029_A_SC, regs,
aba39d27 MB	234	RV3029_ALARM_SECTION_LEN);
52365230 HS	235
	236	if (ret < 0) {
	237	dev_err(&client->dev, "%s: reading alarm section failed\n",
	238	__func__);
	239	return ret;
	240	}
	241
aba39d27 MB	242	tm->tm_sec = bcd2bin(regs[RV3029_A_SC-RV3029_A_SC] & 0x7f);
	243	tm->tm_min = bcd2bin(regs[RV3029_A_MN-RV3029_A_SC] & 0x7f);
	244	tm->tm_hour = bcd2bin(regs[RV3029_A_HR-RV3029_A_SC] & 0x3f);
	245	tm->tm_mday = bcd2bin(regs[RV3029_A_DT-RV3029_A_SC] & 0x3f);
	246	tm->tm_mon = bcd2bin(regs[RV3029_A_MO-RV3029_A_SC] & 0x1f) - 1;
	247	tm->tm_year = bcd2bin(regs[RV3029_A_YR-RV3029_A_SC] & 0x7f) + 100;
	248	tm->tm_wday = bcd2bin(regs[RV3029_A_DW-RV3029_A_SC] & 0x07) - 1;
52365230 HS	249
	250	return 0;
	251	}
	252
	253	static int
aba39d27	254	rv3029_rtc_read_alarm(struct device dev, struct rtc_wkalrm alarm)
52365230	255	{
aba39d27	256	return rv3029_i2c_read_alarm(to_i2c_client(dev), alarm);
52365230 HS	257	}
52365230 HS	258
aba39d27	259	static int rv3029_rtc_i2c_alarm_set_irq(struct i2c_client *client,
52365230 HS	260	int enable)
	261	{
	262	int ret;
	263	u8 buf[1];
	264
	265	/* enable AIE irq */
aba39d27	266	ret = rv3029_i2c_read_regs(client, RV3029_IRQ_CTRL, buf, 1);
52365230 HS	267	if (ret < 0) {
	268	dev_err(&client->dev, "can't read INT reg\n");
	269	return ret;
	270	}
	271	if (enable)
aba39d27	272	buf[0] \|= RV3029_IRQ_CTRL_AIE;
52365230	273	else
aba39d27	274	buf[0] &= ~RV3029_IRQ_CTRL_AIE;
52365230	275
aba39d27	276	ret = rv3029_i2c_write_regs(client, RV3029_IRQ_CTRL, buf, 1);
52365230 HS	277	if (ret < 0) {
	278	dev_err(&client->dev, "can't set INT reg\n");
	279	return ret;
	280	}
	281
	282	return 0;
	283	}
	284
aba39d27 MB	285	static int rv3029_rtc_i2c_set_alarm(struct i2c_client *client,
aba39d27 MB	286	struct rtc_wkalrm *alarm)
52365230 HS	287	{
	288	struct rtc_time *const tm = &alarm->time;
	289	int ret;
	290	u8 regs[8];
	291
	292	/*
	293	* The clock has an 8 bit wide bcd-coded register (they never learn)
	294	* for the year. tm_year is an offset from 1900 and we are interested
	295	* in the 2000-2099 range, so any value less than 100 is invalid.
	296	*/
	297	if (tm->tm_year < 100)
	298	return -EINVAL;
	299
aba39d27	300	ret = rv3029_i2c_get_sr(client, regs);
52365230 HS	301	if (ret < 0) {
	302	dev_err(&client->dev, "%s: reading SR failed\n", __func__);
	303	return -EIO;
	304	}
aba39d27 MB	305	regs[RV3029_A_SC-RV3029_A_SC] = bin2bcd(tm->tm_sec & 0x7f);
	306	regs[RV3029_A_MN-RV3029_A_SC] = bin2bcd(tm->tm_min & 0x7f);
	307	regs[RV3029_A_HR-RV3029_A_SC] = bin2bcd(tm->tm_hour & 0x3f);
	308	regs[RV3029_A_DT-RV3029_A_SC] = bin2bcd(tm->tm_mday & 0x3f);
	309	regs[RV3029_A_MO-RV3029_A_SC] = bin2bcd((tm->tm_mon & 0x1f) - 1);
	310	regs[RV3029_A_DW-RV3029_A_SC] = bin2bcd((tm->tm_wday & 7) - 1);
	311	regs[RV3029_A_YR-RV3029_A_SC] = bin2bcd((tm->tm_year & 0x7f) - 100);
	312
	313	ret = rv3029_i2c_write_regs(client, RV3029_A_SC, regs,
	314	RV3029_ALARM_SECTION_LEN);
52365230 HS	315	if (ret < 0)
	316	return ret;
	317
	318	if (alarm->enabled) {
	319	u8 buf[1];
	320
	321	/* clear AF flag */
aba39d27 MB	322	ret = rv3029_i2c_read_regs(client, RV3029_IRQ_FLAGS,
aba39d27 MB	323	buf, 1);
52365230 HS	324	if (ret < 0) {
	325	dev_err(&client->dev, "can't read alarm flag\n");
	326	return ret;
	327	}
aba39d27 MB	328	buf[0] &= ~RV3029_IRQ_FLAGS_AF;
	329	ret = rv3029_i2c_write_regs(client, RV3029_IRQ_FLAGS,
	330	buf, 1);
52365230 HS	331	if (ret < 0) {
	332	dev_err(&client->dev, "can't set alarm flag\n");
	333	return ret;
	334	}
	335	/* enable AIE irq */
aba39d27	336	ret = rv3029_rtc_i2c_alarm_set_irq(client, 1);
52365230 HS	337	if (ret)
	338	return ret;
	339
	340	dev_dbg(&client->dev, "alarm IRQ armed\n");
	341	} else {
	342	/* disable AIE irq */
aba39d27	343	ret = rv3029_rtc_i2c_alarm_set_irq(client, 0);
52365230 HS	344	if (ret)
	345	return ret;
	346
	347	dev_dbg(&client->dev, "alarm IRQ disabled\n");
	348	}
	349
	350	return 0;
	351	}
	352
aba39d27	353	static int rv3029_rtc_set_alarm(struct device dev, struct rtc_wkalrm alarm)
52365230	354	{
aba39d27	355	return rv3029_rtc_i2c_set_alarm(to_i2c_client(dev), alarm);
52365230 HS	356	}
	357
	358	static int
aba39d27	359	rv3029_i2c_set_time(struct i2c_client client, struct rtc_time const tm)
52365230 HS	360	{
	361	u8 regs[8];
	362	int ret;
	363
	364	/*
	365	* The clock has an 8 bit wide bcd-coded register (they never learn)
	366	* for the year. tm_year is an offset from 1900 and we are interested
	367	* in the 2000-2099 range, so any value less than 100 is invalid.
	368	*/
	369	if (tm->tm_year < 100)
	370	return -EINVAL;
	371
aba39d27 MB	372	regs[RV3029_W_SEC-RV3029_W_SEC] = bin2bcd(tm->tm_sec);
	373	regs[RV3029_W_MINUTES-RV3029_W_SEC] = bin2bcd(tm->tm_min);
	374	regs[RV3029_W_HOURS-RV3029_W_SEC] = bin2bcd(tm->tm_hour);
	375	regs[RV3029_W_DATE-RV3029_W_SEC] = bin2bcd(tm->tm_mday);
	376	regs[RV3029_W_MONTHS-RV3029_W_SEC] = bin2bcd(tm->tm_mon+1);
	377	regs[RV3029_W_DAYS-RV3029_W_SEC] = bin2bcd((tm->tm_wday & 7)+1);
	378	regs[RV3029_W_YEARS-RV3029_W_SEC] = bin2bcd(tm->tm_year - 100);
52365230	379
aba39d27 MB	380	ret = rv3029_i2c_write_regs(client, RV3029_W_SEC, regs,
aba39d27 MB	381	RV3029_WATCH_SECTION_LEN);
52365230 HS	382	if (ret < 0)
	383	return ret;
	384
aba39d27	385	ret = rv3029_i2c_get_sr(client, regs);
52365230 HS	386	if (ret < 0) {
	387	dev_err(&client->dev, "%s: reading SR failed\n", __func__);
	388	return ret;
	389	}
	390	/* clear PON bit */
aba39d27	391	ret = rv3029_i2c_set_sr(client, (regs[0] & ~RV3029_STATUS_PON));
52365230 HS	392	if (ret < 0) {
	393	dev_err(&client->dev, "%s: reading SR failed\n", __func__);
	394	return ret;
	395	}
	396
	397	return 0;
	398	}
	399
aba39d27	400	static int rv3029_rtc_set_time(struct device dev, struct rtc_time tm)
52365230	401	{
aba39d27	402	return rv3029_i2c_set_time(to_i2c_client(dev), tm);
52365230 HS	403	}
52365230 HS	404
aba39d27 MB	405	static const struct rtc_class_ops rv3029_rtc_ops = {
	406	.read_time = rv3029_rtc_read_time,
	407	.set_time = rv3029_rtc_set_time,
	408	.read_alarm = rv3029_rtc_read_alarm,
	409	.set_alarm = rv3029_rtc_set_alarm,
52365230 HS	410	};
52365230 HS	411
aba39d27	412	static struct i2c_device_id rv3029_id[] = {
baba623f	413	{ "rv3029", 0 },
52365230 HS	414	{ "rv3029c2", 0 },
	415	{ }
	416	};
aba39d27	417	MODULE_DEVICE_TABLE(i2c, rv3029_id);
52365230	418
aba39d27 MB	419	static int rv3029_probe(struct i2c_client *client,
aba39d27 MB	420	const struct i2c_device_id *id)
52365230 HS	421	{
	422	struct rtc_device *rtc;
	423	int rc = 0;
	424	u8 buf[1];
	425
	426	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_EMUL))
	427	return -ENODEV;
	428
aba39d27	429	rc = rv3029_i2c_get_sr(client, buf);
67ab2440 GH	430	if (rc < 0) {
	431	dev_err(&client->dev, "reading status failed\n");
	432	return rc;
	433	}
	434
3d7068c9	435	rtc = devm_rtc_device_register(&client->dev, client->name,
aba39d27	436	&rv3029_rtc_ops, THIS_MODULE);
52365230 HS	437
	438	if (IS_ERR(rtc))
	439	return PTR_ERR(rtc);
	440
	441	i2c_set_clientdata(client, rtc);
	442
52365230	443	return 0;
52365230 HS	444	}
52365230 HS	445
aba39d27	446	static struct i2c_driver rv3029_driver = {
52365230 HS	447	.driver = {
	448	.name = "rtc-rv3029c2",
	449	},
aba39d27 MB	450	.probe = rv3029_probe,
aba39d27 MB	451	.id_table = rv3029_id,
52365230 HS	452	};
52365230 HS	453
aba39d27	454	module_i2c_driver(rv3029_driver);
52365230 HS	455
52365230 HS	456	MODULE_AUTHOR("Gregory Hermant <gregory.hermant@calao-systems.com>");
aba39d27	457	MODULE_DESCRIPTION("Micro Crystal RV3029 RTC driver");
52365230	458	MODULE_LICENSE("GPL");