1 // SPDX-License-Identifier: GPL-2.0-only
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>.
9 */
10
11 #include <linux/i2c.h>
12 #include <linux/bcd.h>
13 #include <linux/rtc.h>
14 #include <linux/slab.h>
15 #include <linux/module.h>
16 #include <linux/err.h>
17 #include <linux/of.h>
18 #include <linux/of_device.h>
19 #include <linux/regmap.h>
20
21 /* ISL register offsets */
22 #define ISL12022_REG_SC 0x00
23 #define ISL12022_REG_MN 0x01
24 #define ISL12022_REG_HR 0x02
25 #define ISL12022_REG_DT 0x03
26 #define ISL12022_REG_MO 0x04
27 #define ISL12022_REG_YR 0x05
28 #define ISL12022_REG_DW 0x06
29
30 #define ISL12022_REG_SR 0x07
31 #define ISL12022_REG_INT 0x08
32
33 /* ISL register bits */
34 #define ISL12022_HR_MIL (1 << 7) /* military or 24 hour time */
35
36 #define ISL12022_SR_LBAT85 (1 << 2)
37 #define ISL12022_SR_LBAT75 (1 << 1)
38
39 #define ISL12022_INT_WRTC (1 << 6)
40
41
42 static struct i2c_driver isl12022_driver;
43
44 struct isl12022 {
45 struct rtc_device *rtc;
46 struct regmap *regmap;
47 };
48
49 /*
50 * In the routines that deal directly with the isl12022 hardware, we use
51 * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
52 */
isl12022_rtc_read_time(struct device * dev,struct rtc_time * tm)53 static int isl12022_rtc_read_time(struct device *dev, struct rtc_time *tm)
54 {
55 struct isl12022 *isl12022 = dev_get_drvdata(dev);
56 struct regmap *regmap = isl12022->regmap;
57 uint8_t buf[ISL12022_REG_INT + 1];
58 int ret;
59
60 ret = regmap_bulk_read(regmap, ISL12022_REG_SC, buf, sizeof(buf));
61 if (ret)
62 return ret;
63
64 if (buf[ISL12022_REG_SR] & (ISL12022_SR_LBAT85 | ISL12022_SR_LBAT75)) {
65 dev_warn(dev,
66 "voltage dropped below %u%%, "
67 "date and time is not reliable.\n",
68 buf[ISL12022_REG_SR] & ISL12022_SR_LBAT85 ? 85 : 75);
69 }
70
71 dev_dbg(dev,
72 "%s: raw data is sec=%02x, min=%02x, hr=%02x, "
73 "mday=%02x, mon=%02x, year=%02x, wday=%02x, "
74 "sr=%02x, int=%02x",
75 __func__,
76 buf[ISL12022_REG_SC],
77 buf[ISL12022_REG_MN],
78 buf[ISL12022_REG_HR],
79 buf[ISL12022_REG_DT],
80 buf[ISL12022_REG_MO],
81 buf[ISL12022_REG_YR],
82 buf[ISL12022_REG_DW],
83 buf[ISL12022_REG_SR],
84 buf[ISL12022_REG_INT]);
85
86 tm->tm_sec = bcd2bin(buf[ISL12022_REG_SC] & 0x7F);
87 tm->tm_min = bcd2bin(buf[ISL12022_REG_MN] & 0x7F);
88 tm->tm_hour = bcd2bin(buf[ISL12022_REG_HR] & 0x3F);
89 tm->tm_mday = bcd2bin(buf[ISL12022_REG_DT] & 0x3F);
90 tm->tm_wday = buf[ISL12022_REG_DW] & 0x07;
91 tm->tm_mon = bcd2bin(buf[ISL12022_REG_MO] & 0x1F) - 1;
92 tm->tm_year = bcd2bin(buf[ISL12022_REG_YR]) + 100;
93
94 dev_dbg(dev, "%s: %ptR\n", __func__, tm);
95
96 return 0;
97 }
98
isl12022_rtc_set_time(struct device * dev,struct rtc_time * tm)99 static int isl12022_rtc_set_time(struct device *dev, struct rtc_time *tm)
100 {
101 struct isl12022 *isl12022 = dev_get_drvdata(dev);
102 struct regmap *regmap = isl12022->regmap;
103 int ret;
104 uint8_t buf[ISL12022_REG_DW + 1];
105
106 dev_dbg(dev, "%s: %ptR\n", __func__, tm);
107
108 /* Ensure the write enable bit is set. */
109 ret = regmap_update_bits(regmap, ISL12022_REG_INT,
110 ISL12022_INT_WRTC, ISL12022_INT_WRTC);
111 if (ret)
112 return ret;
113
114 /* hours, minutes and seconds */
115 buf[ISL12022_REG_SC] = bin2bcd(tm->tm_sec);
116 buf[ISL12022_REG_MN] = bin2bcd(tm->tm_min);
117 buf[ISL12022_REG_HR] = bin2bcd(tm->tm_hour) | ISL12022_HR_MIL;
118
119 buf[ISL12022_REG_DT] = bin2bcd(tm->tm_mday);
120
121 /* month, 1 - 12 */
122 buf[ISL12022_REG_MO] = bin2bcd(tm->tm_mon + 1);
123
124 /* year and century */
125 buf[ISL12022_REG_YR] = bin2bcd(tm->tm_year % 100);
126
127 buf[ISL12022_REG_DW] = tm->tm_wday & 0x07;
128
129 return regmap_bulk_write(isl12022->regmap, ISL12022_REG_SC,
130 buf, sizeof(buf));
131 }
132
133 static const struct rtc_class_ops isl12022_rtc_ops = {
134 .read_time = isl12022_rtc_read_time,
135 .set_time = isl12022_rtc_set_time,
136 };
137
138 static const struct regmap_config regmap_config = {
139 .reg_bits = 8,
140 .val_bits = 8,
141 .use_single_write = true,
142 };
143
isl12022_probe(struct i2c_client * client)144 static int isl12022_probe(struct i2c_client *client)
145 {
146 struct isl12022 *isl12022;
147
148 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
149 return -ENODEV;
150
151 isl12022 = devm_kzalloc(&client->dev, sizeof(struct isl12022),
152 GFP_KERNEL);
153 if (!isl12022)
154 return -ENOMEM;
155 dev_set_drvdata(&client->dev, isl12022);
156
157 isl12022->regmap = devm_regmap_init_i2c(client, ®map_config);
158 if (IS_ERR(isl12022->regmap)) {
159 dev_err(&client->dev, "regmap allocation failed\n");
160 return PTR_ERR(isl12022->regmap);
161 }
162
163 isl12022->rtc = devm_rtc_allocate_device(&client->dev);
164 if (IS_ERR(isl12022->rtc))
165 return PTR_ERR(isl12022->rtc);
166
167 isl12022->rtc->ops = &isl12022_rtc_ops;
168 isl12022->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
169 isl12022->rtc->range_max = RTC_TIMESTAMP_END_2099;
170
171 return devm_rtc_register_device(isl12022->rtc);
172 }
173
174 #ifdef CONFIG_OF
175 static const struct of_device_id isl12022_dt_match[] = {
176 { .compatible = "isl,isl12022" }, /* for backward compat., don't use */
177 { .compatible = "isil,isl12022" },
178 { },
179 };
180 MODULE_DEVICE_TABLE(of, isl12022_dt_match);
181 #endif
182
183 static const struct i2c_device_id isl12022_id[] = {
184 { "isl12022", 0 },
185 { }
186 };
187 MODULE_DEVICE_TABLE(i2c, isl12022_id);
188
189 static struct i2c_driver isl12022_driver = {
190 .driver = {
191 .name = "rtc-isl12022",
192 #ifdef CONFIG_OF
193 .of_match_table = of_match_ptr(isl12022_dt_match),
194 #endif
195 },
196 .probe_new = isl12022_probe,
197 .id_table = isl12022_id,
198 };
199
200 module_i2c_driver(isl12022_driver);
201
202 MODULE_AUTHOR("roman.fietze@telemotive.de");
203 MODULE_DESCRIPTION("ISL 12022 RTC driver");
204 MODULE_LICENSE("GPL");
205