[linux-block.git] / drivers / rtc / rtc-isl12022.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * An I2C driver for the Intersil ISL 12022
 *
 * Author: Roman Fietze <roman.fietze@telemotive.de>
 *
 * Based on the Philips PCF8563 RTC
 * by Alessandro Zummo <a.zummo@towertech.it>.
 */

#include <linux/bcd.h>
#include <linux/err.h>
#include <linux/hwmon.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/rtc.h>
#include <linux/slab.h>

#include <asm/byteorder.h>

/* ISL register offsets */
#define ISL12022_REG_SC		0x00
#define ISL12022_REG_MN		0x01
#define ISL12022_REG_HR		0x02
#define ISL12022_REG_DT		0x03
#define ISL12022_REG_MO		0x04
#define ISL12022_REG_YR		0x05
#define ISL12022_REG_DW		0x06

#define ISL12022_REG_SR		0x07
#define ISL12022_REG_INT	0x08

#define ISL12022_REG_BETA	0x0d
#define ISL12022_REG_TEMP_L	0x28

/* ISL register bits */
#define ISL12022_HR_MIL		(1 << 7)	/* military or 24 hour time */

#define ISL12022_SR_LBAT85	(1 << 2)
#define ISL12022_SR_LBAT75	(1 << 1)

#define ISL12022_INT_WRTC	(1 << 6)

#define ISL12022_BETA_TSE	(1 << 7)

static umode_t isl12022_hwmon_is_visible(const void *data,
					 enum hwmon_sensor_types type,
					 u32 attr, int channel)
{
	if (type == hwmon_temp && attr == hwmon_temp_input)
		return 0444;

	return 0;
}

/*
 * A user-initiated temperature conversion is not started by this function,
 * so the temperature is updated once every ~60 seconds.
 */
static int isl12022_hwmon_read_temp(struct device *dev, long *mC)
{
	struct regmap *regmap = dev_get_drvdata(dev);
	int temp, ret;
	__le16 buf;

	ret = regmap_bulk_read(regmap, ISL12022_REG_TEMP_L, &buf, sizeof(buf));
	if (ret)
		return ret;
	/*
	 * Temperature is represented as a 10-bit number, unit half-Kelvins.
	 */
	temp = le16_to_cpu(buf);
	temp *= 500;
	temp -= 273000;

	*mC = temp;

	return 0;
}

static int isl12022_hwmon_read(struct device *dev,
			       enum hwmon_sensor_types type,
			       u32 attr, int channel, long *val)
{
	if (type == hwmon_temp && attr == hwmon_temp_input)
		return isl12022_hwmon_read_temp(dev, val);

	return -EOPNOTSUPP;
}

static const struct hwmon_channel_info *isl12022_hwmon_info[] = {
	HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT),
	NULL
};

static const struct hwmon_ops isl12022_hwmon_ops = {
	.is_visible = isl12022_hwmon_is_visible,
	.read = isl12022_hwmon_read,
};

static const struct hwmon_chip_info isl12022_hwmon_chip_info = {
	.ops = &isl12022_hwmon_ops,
	.info = isl12022_hwmon_info,
};

static void isl12022_hwmon_register(struct device *dev)
{
	struct regmap *regmap = dev_get_drvdata(dev);
	struct device *hwmon;
	int ret;

	if (!IS_REACHABLE(CONFIG_HWMON))
		return;

	ret = regmap_update_bits(regmap, ISL12022_REG_BETA,
				 ISL12022_BETA_TSE, ISL12022_BETA_TSE);
	if (ret) {
		dev_warn(dev, "unable to enable temperature sensor\n");
		return;
	}

	hwmon = devm_hwmon_device_register_with_info(dev, "isl12022", regmap,
						     &isl12022_hwmon_chip_info,
						     NULL);
	if (IS_ERR(hwmon))
		dev_warn(dev, "unable to register hwmon device: %pe\n", hwmon);
}

/*
 * In the routines that deal directly with the isl12022 hardware, we use
 * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
 */
static int isl12022_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct regmap *regmap = dev_get_drvdata(dev);
	uint8_t buf[ISL12022_REG_INT + 1];
	int ret;

	ret = regmap_bulk_read(regmap, ISL12022_REG_SC, buf, sizeof(buf));
	if (ret)
		return ret;

	if (buf[ISL12022_REG_SR] & (ISL12022_SR_LBAT85 | ISL12022_SR_LBAT75)) {
		dev_warn(dev,
			 "voltage dropped below %u%%, date and time is not reliable.\n",
			 buf[ISL12022_REG_SR] & ISL12022_SR_LBAT85 ? 85 : 75);
	}

	dev_dbg(dev,
		"raw data is sec=%02x, min=%02x, hr=%02x, mday=%02x, mon=%02x, year=%02x, wday=%02x, sr=%02x, int=%02x",
		buf[ISL12022_REG_SC],
		buf[ISL12022_REG_MN],
		buf[ISL12022_REG_HR],
		buf[ISL12022_REG_DT],
		buf[ISL12022_REG_MO],
		buf[ISL12022_REG_YR],
		buf[ISL12022_REG_DW],
		buf[ISL12022_REG_SR],
		buf[ISL12022_REG_INT]);

	tm->tm_sec = bcd2bin(buf[ISL12022_REG_SC] & 0x7F);
	tm->tm_min = bcd2bin(buf[ISL12022_REG_MN] & 0x7F);
	tm->tm_hour = bcd2bin(buf[ISL12022_REG_HR] & 0x3F);
	tm->tm_mday = bcd2bin(buf[ISL12022_REG_DT] & 0x3F);
	tm->tm_wday = buf[ISL12022_REG_DW] & 0x07;
	tm->tm_mon = bcd2bin(buf[ISL12022_REG_MO] & 0x1F) - 1;
	tm->tm_year = bcd2bin(buf[ISL12022_REG_YR]) + 100;

	dev_dbg(dev, "%s: %ptR\n", __func__, tm);

	return 0;
}

static int isl12022_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct regmap *regmap = dev_get_drvdata(dev);
	int ret;
	uint8_t buf[ISL12022_REG_DW + 1];

	dev_dbg(dev, "%s: %ptR\n", __func__, tm);

	/* Ensure the write enable bit is set. */
	ret = regmap_update_bits(regmap, ISL12022_REG_INT,
				 ISL12022_INT_WRTC, ISL12022_INT_WRTC);
	if (ret)
		return ret;

	/* hours, minutes and seconds */
	buf[ISL12022_REG_SC] = bin2bcd(tm->tm_sec);
	buf[ISL12022_REG_MN] = bin2bcd(tm->tm_min);
	buf[ISL12022_REG_HR] = bin2bcd(tm->tm_hour) | ISL12022_HR_MIL;

	buf[ISL12022_REG_DT] = bin2bcd(tm->tm_mday);

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

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

	buf[ISL12022_REG_DW] = tm->tm_wday & 0x07;

	return regmap_bulk_write(regmap, ISL12022_REG_SC, buf, sizeof(buf));
}

static const struct rtc_class_ops isl12022_rtc_ops = {
	.read_time	= isl12022_rtc_read_time,
	.set_time	= isl12022_rtc_set_time,
};

static const struct regmap_config regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.use_single_write = true,
};

static int isl12022_probe(struct i2c_client *client)
{
	struct rtc_device *rtc;
	struct regmap *regmap;

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

	regmap = devm_regmap_init_i2c(client, &regmap_config);
	if (IS_ERR(regmap)) {
		dev_err(&client->dev, "regmap allocation failed\n");
		return PTR_ERR(regmap);
	}

	dev_set_drvdata(&client->dev, regmap);

	isl12022_hwmon_register(&client->dev);

	rtc = devm_rtc_allocate_device(&client->dev);
	if (IS_ERR(rtc))
		return PTR_ERR(rtc);

	rtc->ops = &isl12022_rtc_ops;
	rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
	rtc->range_max = RTC_TIMESTAMP_END_2099;

	return devm_rtc_register_device(rtc);
}

static const struct of_device_id isl12022_dt_match[] = {
	{ .compatible = "isl,isl12022" }, /* for backward compat., don't use */
	{ .compatible = "isil,isl12022" },
	{ },
};
MODULE_DEVICE_TABLE(of, isl12022_dt_match);

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

static struct i2c_driver isl12022_driver = {
	.driver		= {
		.name	= "rtc-isl12022",
		.of_match_table = isl12022_dt_match,
	},
	.probe_new	= isl12022_probe,
	.id_table	= isl12022_id,
};

module_i2c_driver(isl12022_driver);

MODULE_AUTHOR("roman.fietze@telemotive.de");
MODULE_DESCRIPTION("ISL 12022 RTC driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
d6c7428f RF	2	/*
	3	* An I2C driver for the Intersil ISL 12022
	4	*
	5	* Author: Roman Fietze <roman.fietze@telemotive.de>
	6	*
	7	* Based on the Philips PCF8563 RTC
	8	* by Alessandro Zummo <a.zummo@towertech.it>.
d6c7428f RF	9	*/
d6c7428f RF	10
d6c7428f	11	#include <linux/bcd.h>
17cc54b2	12	#include <linux/err.h>
8d816c1e	13	#include <linux/hwmon.h>
303eac65 AS	14	#include <linux/i2c.h>
	15	#include <linux/module.h>
	16	#include <linux/regmap.h>
	17	#include <linux/rtc.h>
	18	#include <linux/slab.h>
d6c7428f	19
93219a4f AS	20	#include <asm/byteorder.h>
93219a4f AS	21
d6c7428f RF	22	/* ISL register offsets */
	23	#define ISL12022_REG_SC 0x00
	24	#define ISL12022_REG_MN 0x01
	25	#define ISL12022_REG_HR 0x02
	26	#define ISL12022_REG_DT 0x03
	27	#define ISL12022_REG_MO 0x04
	28	#define ISL12022_REG_YR 0x05
	29	#define ISL12022_REG_DW 0x06
	30
	31	#define ISL12022_REG_SR 0x07
	32	#define ISL12022_REG_INT 0x08
	33
8d816c1e RV	34	#define ISL12022_REG_BETA 0x0d
	35	#define ISL12022_REG_TEMP_L 0x28
	36
d6c7428f RF	37	/* ISL register bits */
	38	#define ISL12022_HR_MIL (1 << 7) /* military or 24 hour time */
	39
	40	#define ISL12022_SR_LBAT85 (1 << 2)
	41	#define ISL12022_SR_LBAT75 (1 << 1)
	42
	43	#define ISL12022_INT_WRTC (1 << 6)
	44
8d816c1e	45	#define ISL12022_BETA_TSE (1 << 7)
d6c7428f	46
8d816c1e RV	47	static umode_t isl12022_hwmon_is_visible(const void *data,
	48	enum hwmon_sensor_types type,
	49	u32 attr, int channel)
	50	{
	51	if (type == hwmon_temp && attr == hwmon_temp_input)
	52	return 0444;
	53
	54	return 0;
	55	}
	56
	57	/*
	58	* A user-initiated temperature conversion is not started by this function,
	59	* so the temperature is updated once every ~60 seconds.
	60	*/
	61	static int isl12022_hwmon_read_temp(struct device dev, long mC)
	62	{
f525b210	63	struct regmap *regmap = dev_get_drvdata(dev);
8d816c1e	64	int temp, ret;
93219a4f	65	__le16 buf;
8d816c1e	66
93219a4f	67	ret = regmap_bulk_read(regmap, ISL12022_REG_TEMP_L, &buf, sizeof(buf));
8d816c1e RV	68	if (ret)
	69	return ret;
	70	/*
	71	* Temperature is represented as a 10-bit number, unit half-Kelvins.
	72	*/
93219a4f	73	temp = le16_to_cpu(buf);
8d816c1e RV	74	temp *= 500;
	75	temp -= 273000;
	76
	77	*mC = temp;
	78
	79	return 0;
	80	}
	81
	82	static int isl12022_hwmon_read(struct device *dev,
	83	enum hwmon_sensor_types type,
	84	u32 attr, int channel, long *val)
	85	{
	86	if (type == hwmon_temp && attr == hwmon_temp_input)
	87	return isl12022_hwmon_read_temp(dev, val);
	88
	89	return -EOPNOTSUPP;
	90	}
	91
	92	static const struct hwmon_channel_info *isl12022_hwmon_info[] = {
	93	HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT),
	94	NULL
	95	};
	96
	97	static const struct hwmon_ops isl12022_hwmon_ops = {
	98	.is_visible = isl12022_hwmon_is_visible,
	99	.read = isl12022_hwmon_read,
	100	};
	101
	102	static const struct hwmon_chip_info isl12022_hwmon_chip_info = {
	103	.ops = &isl12022_hwmon_ops,
	104	.info = isl12022_hwmon_info,
	105	};
	106
	107	static void isl12022_hwmon_register(struct device *dev)
	108	{
f525b210	109	struct regmap *regmap = dev_get_drvdata(dev);
8d816c1e RV	110	struct device *hwmon;
	111	int ret;
	112
	113	if (!IS_REACHABLE(CONFIG_HWMON))
	114	return;
	115
f525b210	116	ret = regmap_update_bits(regmap, ISL12022_REG_BETA,
8d816c1e RV	117	ISL12022_BETA_TSE, ISL12022_BETA_TSE);
	118	if (ret) {
	119	dev_warn(dev, "unable to enable temperature sensor\n");
	120	return;
	121	}
	122
f525b210	123	hwmon = devm_hwmon_device_register_with_info(dev, "isl12022", regmap,
8d816c1e RV	124	&isl12022_hwmon_chip_info,
	125	NULL);
	126	if (IS_ERR(hwmon))
	127	dev_warn(dev, "unable to register hwmon device: %pe\n", hwmon);
	128	}
	129
d6c7428f RF	130	/*
	131	* In the routines that deal directly with the isl12022 hardware, we use
	132	* rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
	133	*/
143d92be	134	static int isl12022_rtc_read_time(struct device dev, struct rtc_time tm)
d6c7428f	135	{
f525b210	136	struct regmap *regmap = dev_get_drvdata(dev);
d6c7428f RF	137	uint8_t buf[ISL12022_REG_INT + 1];
	138	int ret;
	139
b1a1baa6	140	ret = regmap_bulk_read(regmap, ISL12022_REG_SC, buf, sizeof(buf));
d6c7428f RF	141	if (ret)
	142	return ret;
	143
	144	if (buf[ISL12022_REG_SR] & (ISL12022_SR_LBAT85 \| ISL12022_SR_LBAT75)) {
ca358871	145	dev_warn(dev,
9bb1e189	146	"voltage dropped below %u%%, date and time is not reliable.\n",
d6c7428f RF	147	buf[ISL12022_REG_SR] & ISL12022_SR_LBAT85 ? 85 : 75);
	148	}
	149
ca358871	150	dev_dbg(dev,
9bb1e189	151	"raw data is sec=%02x, min=%02x, hr=%02x, mday=%02x, mon=%02x, year=%02x, wday=%02x, sr=%02x, int=%02x",
d6c7428f RF	152	buf[ISL12022_REG_SC],
	153	buf[ISL12022_REG_MN],
	154	buf[ISL12022_REG_HR],
	155	buf[ISL12022_REG_DT],
	156	buf[ISL12022_REG_MO],
	157	buf[ISL12022_REG_YR],
	158	buf[ISL12022_REG_DW],
	159	buf[ISL12022_REG_SR],
	160	buf[ISL12022_REG_INT]);
	161
	162	tm->tm_sec = bcd2bin(buf[ISL12022_REG_SC] & 0x7F);
	163	tm->tm_min = bcd2bin(buf[ISL12022_REG_MN] & 0x7F);
	164	tm->tm_hour = bcd2bin(buf[ISL12022_REG_HR] & 0x3F);
	165	tm->tm_mday = bcd2bin(buf[ISL12022_REG_DT] & 0x3F);
	166	tm->tm_wday = buf[ISL12022_REG_DW] & 0x07;
	167	tm->tm_mon = bcd2bin(buf[ISL12022_REG_MO] & 0x1F) - 1;
	168	tm->tm_year = bcd2bin(buf[ISL12022_REG_YR]) + 100;
	169
7093b8a4	170	dev_dbg(dev, "%s: %ptR\n", __func__, tm);
d6c7428f	171
22652ba7	172	return 0;
d6c7428f RF	173	}
d6c7428f RF	174
143d92be	175	static int isl12022_rtc_set_time(struct device dev, struct rtc_time tm)
d6c7428f	176	{
f525b210	177	struct regmap *regmap = dev_get_drvdata(dev);
d6c7428f RF	178	int ret;
	179	uint8_t buf[ISL12022_REG_DW + 1];
	180
7093b8a4	181	dev_dbg(dev, "%s: %ptR\n", __func__, tm);
d6c7428f	182
b1a1baa6 RV	183	/* Ensure the write enable bit is set. */
	184	ret = regmap_update_bits(regmap, ISL12022_REG_INT,
	185	ISL12022_INT_WRTC, ISL12022_INT_WRTC);
	186	if (ret)
	187	return ret;
d6c7428f RF	188
	189	/* hours, minutes and seconds */
	190	buf[ISL12022_REG_SC] = bin2bcd(tm->tm_sec);
	191	buf[ISL12022_REG_MN] = bin2bcd(tm->tm_min);
6d23b258	192	buf[ISL12022_REG_HR] = bin2bcd(tm->tm_hour) \| ISL12022_HR_MIL;
d6c7428f RF	193
	194	buf[ISL12022_REG_DT] = bin2bcd(tm->tm_mday);
	195
	196	/* month, 1 - 12 */
	197	buf[ISL12022_REG_MO] = bin2bcd(tm->tm_mon + 1);
	198
	199	/* year and century */
	200	buf[ISL12022_REG_YR] = bin2bcd(tm->tm_year % 100);
	201
	202	buf[ISL12022_REG_DW] = tm->tm_wday & 0x07;
	203
f525b210	204	return regmap_bulk_write(regmap, ISL12022_REG_SC, buf, sizeof(buf));
d6c7428f RF	205	}
d6c7428f RF	206
d6c7428f RF	207	static const struct rtc_class_ops isl12022_rtc_ops = {
	208	.read_time = isl12022_rtc_read_time,
	209	.set_time = isl12022_rtc_set_time,
	210	};
	211
b1a1baa6 RV	212	static const struct regmap_config regmap_config = {
	213	.reg_bits = 8,
	214	.val_bits = 8,
	215	.use_single_write = true,
	216	};
	217
3f4a3322	218	static int isl12022_probe(struct i2c_client *client)
d6c7428f	219	{
f525b210 AS	220	struct rtc_device *rtc;
f525b210 AS	221	struct regmap *regmap;
d6c7428f	222
d6c7428f RF	223	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
	224	return -ENODEV;
	225
f525b210 AS	226	regmap = devm_regmap_init_i2c(client, &regmap_config);
f525b210 AS	227	if (IS_ERR(regmap)) {
b1a1baa6	228	dev_err(&client->dev, "regmap allocation failed\n");
f525b210	229	return PTR_ERR(regmap);
b1a1baa6 RV	230	}
b1a1baa6 RV	231
f525b210 AS	232	dev_set_drvdata(&client->dev, regmap);
f525b210 AS	233
8d816c1e RV	234	isl12022_hwmon_register(&client->dev);
8d816c1e RV	235
f525b210 AS	236	rtc = devm_rtc_allocate_device(&client->dev);
	237	if (IS_ERR(rtc))
	238	return PTR_ERR(rtc);
a35a2ad2	239
f525b210 AS	240	rtc->ops = &isl12022_rtc_ops;
	241	rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
	242	rtc->range_max = RTC_TIMESTAMP_END_2099;
a35a2ad2	243
f525b210	244	return devm_rtc_register_device(rtc);
d6c7428f RF	245	}
d6c7428f RF	246
a28885bc	247	static const struct of_device_id isl12022_dt_match[] = {
c5cd8273 AE	248	{ .compatible = "isl,isl12022" }, /* for backward compat., don't use */
c5cd8273 AE	249	{ .compatible = "isil,isl12022" },
db04d628 SL	250	{ },
db04d628 SL	251	};
1c4fc295	252	MODULE_DEVICE_TABLE(of, isl12022_dt_match);
db04d628	253
d6c7428f RF	254	static const struct i2c_device_id isl12022_id[] = {
d6c7428f RF	255	{ "isl12022", 0 },
d6c7428f RF	256	{ }
	257	};
	258	MODULE_DEVICE_TABLE(i2c, isl12022_id);
	259
	260	static struct i2c_driver isl12022_driver = {
	261	.driver = {
	262	.name = "rtc-isl12022",
c8ae2735	263	.of_match_table = isl12022_dt_match,
d6c7428f	264	},
3f4a3322	265	.probe_new = isl12022_probe,
d6c7428f RF	266	.id_table = isl12022_id,
	267	};
	268
0abc9201	269	module_i2c_driver(isl12022_driver);
d6c7428f RF	270
	271	MODULE_AUTHOR("roman.fietze@telemotive.de");
	272	MODULE_DESCRIPTION("ISL 12022 RTC driver");
	273	MODULE_LICENSE("GPL");