Commit | Line | Data |
---|---|---|
6d2130e6 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
68298c2d ST |
2 | /* |
3 | * Driver for the Epson RTC module RX-6110 SA | |
4 | * | |
5 | * Copyright(C) 2015 Pengutronix, Steffen Trumtrar <kernel@pengutronix.de> | |
6 | * Copyright(C) SEIKO EPSON CORPORATION 2013. All rights reserved. | |
68298c2d ST |
7 | */ |
8 | ||
9 | #include <linux/bcd.h> | |
10 | #include <linux/init.h> | |
11 | #include <linux/kernel.h> | |
12 | #include <linux/module.h> | |
13 | #include <linux/of_gpio.h> | |
14 | #include <linux/regmap.h> | |
15 | #include <linux/rtc.h> | |
f9bf089a DG |
16 | #include <linux/of.h> |
17 | #include <linux/of_device.h> | |
68298c2d ST |
18 | #include <linux/spi/spi.h> |
19 | ||
20 | /* RX-6110 Register definitions */ | |
21 | #define RX6110_REG_SEC 0x10 | |
22 | #define RX6110_REG_MIN 0x11 | |
23 | #define RX6110_REG_HOUR 0x12 | |
24 | #define RX6110_REG_WDAY 0x13 | |
25 | #define RX6110_REG_MDAY 0x14 | |
26 | #define RX6110_REG_MONTH 0x15 | |
27 | #define RX6110_REG_YEAR 0x16 | |
28 | #define RX6110_REG_RES1 0x17 | |
29 | #define RX6110_REG_ALMIN 0x18 | |
30 | #define RX6110_REG_ALHOUR 0x19 | |
31 | #define RX6110_REG_ALWDAY 0x1A | |
32 | #define RX6110_REG_TCOUNT0 0x1B | |
33 | #define RX6110_REG_TCOUNT1 0x1C | |
34 | #define RX6110_REG_EXT 0x1D | |
35 | #define RX6110_REG_FLAG 0x1E | |
36 | #define RX6110_REG_CTRL 0x1F | |
37 | #define RX6110_REG_USER0 0x20 | |
38 | #define RX6110_REG_USER1 0x21 | |
39 | #define RX6110_REG_USER2 0x22 | |
40 | #define RX6110_REG_USER3 0x23 | |
41 | #define RX6110_REG_USER4 0x24 | |
42 | #define RX6110_REG_USER5 0x25 | |
43 | #define RX6110_REG_USER6 0x26 | |
44 | #define RX6110_REG_USER7 0x27 | |
45 | #define RX6110_REG_USER8 0x28 | |
46 | #define RX6110_REG_USER9 0x29 | |
47 | #define RX6110_REG_USERA 0x2A | |
48 | #define RX6110_REG_USERB 0x2B | |
49 | #define RX6110_REG_USERC 0x2C | |
50 | #define RX6110_REG_USERD 0x2D | |
51 | #define RX6110_REG_USERE 0x2E | |
52 | #define RX6110_REG_USERF 0x2F | |
53 | #define RX6110_REG_RES2 0x30 | |
54 | #define RX6110_REG_RES3 0x31 | |
55 | #define RX6110_REG_IRQ 0x32 | |
56 | ||
57 | #define RX6110_BIT_ALARM_EN BIT(7) | |
58 | ||
59 | /* Extension Register (1Dh) bit positions */ | |
60 | #define RX6110_BIT_EXT_TSEL0 BIT(0) | |
61 | #define RX6110_BIT_EXT_TSEL1 BIT(1) | |
62 | #define RX6110_BIT_EXT_TSEL2 BIT(2) | |
63 | #define RX6110_BIT_EXT_WADA BIT(3) | |
64 | #define RX6110_BIT_EXT_TE BIT(4) | |
65 | #define RX6110_BIT_EXT_USEL BIT(5) | |
66 | #define RX6110_BIT_EXT_FSEL0 BIT(6) | |
67 | #define RX6110_BIT_EXT_FSEL1 BIT(7) | |
68 | ||
69 | /* Flag Register (1Eh) bit positions */ | |
70 | #define RX6110_BIT_FLAG_VLF BIT(1) | |
71 | #define RX6110_BIT_FLAG_AF BIT(3) | |
72 | #define RX6110_BIT_FLAG_TF BIT(4) | |
73 | #define RX6110_BIT_FLAG_UF BIT(5) | |
74 | ||
75 | /* Control Register (1Fh) bit positions */ | |
76 | #define RX6110_BIT_CTRL_TBKE BIT(0) | |
77 | #define RX6110_BIT_CTRL_TBKON BIT(1) | |
78 | #define RX6110_BIT_CTRL_TSTP BIT(2) | |
79 | #define RX6110_BIT_CTRL_AIE BIT(3) | |
80 | #define RX6110_BIT_CTRL_TIE BIT(4) | |
81 | #define RX6110_BIT_CTRL_UIE BIT(5) | |
82 | #define RX6110_BIT_CTRL_STOP BIT(6) | |
83 | #define RX6110_BIT_CTRL_TEST BIT(7) | |
84 | ||
85 | enum { | |
86 | RTC_SEC = 0, | |
87 | RTC_MIN, | |
88 | RTC_HOUR, | |
89 | RTC_WDAY, | |
90 | RTC_MDAY, | |
91 | RTC_MONTH, | |
92 | RTC_YEAR, | |
93 | RTC_NR_TIME | |
94 | }; | |
95 | ||
96 | #define RX6110_DRIVER_NAME "rx6110" | |
97 | ||
98 | struct rx6110_data { | |
99 | struct rtc_device *rtc; | |
100 | struct regmap *regmap; | |
101 | }; | |
102 | ||
103 | /** | |
104 | * rx6110_rtc_tm_to_data - convert rtc_time to native time encoding | |
105 | * | |
106 | * @tm: holds date and time | |
107 | * @data: holds the encoding in rx6110 native form | |
108 | */ | |
109 | static int rx6110_rtc_tm_to_data(struct rtc_time *tm, u8 *data) | |
110 | { | |
a3f60bb3 | 111 | pr_debug("%s: date %ptRr\n", __func__, tm); |
68298c2d ST |
112 | |
113 | /* | |
114 | * The year in the RTC is a value between 0 and 99. | |
115 | * Assume that this represents the current century | |
116 | * and disregard all other values. | |
117 | */ | |
118 | if (tm->tm_year < 100 || tm->tm_year >= 200) | |
119 | return -EINVAL; | |
120 | ||
121 | data[RTC_SEC] = bin2bcd(tm->tm_sec); | |
122 | data[RTC_MIN] = bin2bcd(tm->tm_min); | |
123 | data[RTC_HOUR] = bin2bcd(tm->tm_hour); | |
124 | data[RTC_WDAY] = BIT(bin2bcd(tm->tm_wday)); | |
125 | data[RTC_MDAY] = bin2bcd(tm->tm_mday); | |
126 | data[RTC_MONTH] = bin2bcd(tm->tm_mon + 1); | |
127 | data[RTC_YEAR] = bin2bcd(tm->tm_year % 100); | |
128 | ||
129 | return 0; | |
130 | } | |
131 | ||
132 | /** | |
133 | * rx6110_data_to_rtc_tm - convert native time encoding to rtc_time | |
134 | * | |
135 | * @data: holds the encoding in rx6110 native form | |
136 | * @tm: holds date and time | |
137 | */ | |
138 | static int rx6110_data_to_rtc_tm(u8 *data, struct rtc_time *tm) | |
139 | { | |
140 | tm->tm_sec = bcd2bin(data[RTC_SEC] & 0x7f); | |
141 | tm->tm_min = bcd2bin(data[RTC_MIN] & 0x7f); | |
142 | /* only 24-hour clock */ | |
143 | tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3f); | |
144 | tm->tm_wday = ffs(data[RTC_WDAY] & 0x7f); | |
145 | tm->tm_mday = bcd2bin(data[RTC_MDAY] & 0x3f); | |
146 | tm->tm_mon = bcd2bin(data[RTC_MONTH] & 0x1f) - 1; | |
147 | tm->tm_year = bcd2bin(data[RTC_YEAR]) + 100; | |
148 | ||
a3f60bb3 | 149 | pr_debug("%s: date %ptRr\n", __func__, tm); |
68298c2d ST |
150 | |
151 | /* | |
152 | * The year in the RTC is a value between 0 and 99. | |
153 | * Assume that this represents the current century | |
154 | * and disregard all other values. | |
155 | */ | |
156 | if (tm->tm_year < 100 || tm->tm_year >= 200) | |
157 | return -EINVAL; | |
158 | ||
159 | return 0; | |
160 | } | |
161 | ||
162 | /** | |
163 | * rx6110_set_time - set the current time in the rx6110 registers | |
164 | * | |
165 | * @dev: the rtc device in use | |
166 | * @tm: holds date and time | |
167 | * | |
168 | * BUG: The HW assumes every year that is a multiple of 4 to be a leap | |
169 | * year. Next time this is wrong is 2100, which will not be a leap year | |
170 | * | |
171 | * Note: If STOP is not set/cleared, the clock will start when the seconds | |
172 | * register is written | |
173 | * | |
174 | */ | |
175 | static int rx6110_set_time(struct device *dev, struct rtc_time *tm) | |
176 | { | |
177 | struct rx6110_data *rx6110 = dev_get_drvdata(dev); | |
178 | u8 data[RTC_NR_TIME]; | |
179 | int ret; | |
180 | ||
181 | ret = rx6110_rtc_tm_to_data(tm, data); | |
182 | if (ret < 0) | |
183 | return ret; | |
184 | ||
185 | /* set STOP bit before changing clock/calendar */ | |
186 | ret = regmap_update_bits(rx6110->regmap, RX6110_REG_CTRL, | |
187 | RX6110_BIT_CTRL_STOP, RX6110_BIT_CTRL_STOP); | |
188 | if (ret) | |
189 | return ret; | |
190 | ||
191 | ret = regmap_bulk_write(rx6110->regmap, RX6110_REG_SEC, data, | |
192 | RTC_NR_TIME); | |
193 | if (ret) | |
194 | return ret; | |
195 | ||
196 | /* The time in the RTC is valid. Be sure to have VLF cleared. */ | |
197 | ret = regmap_update_bits(rx6110->regmap, RX6110_REG_FLAG, | |
198 | RX6110_BIT_FLAG_VLF, 0); | |
199 | if (ret) | |
200 | return ret; | |
201 | ||
202 | /* clear STOP bit after changing clock/calendar */ | |
203 | ret = regmap_update_bits(rx6110->regmap, RX6110_REG_CTRL, | |
204 | RX6110_BIT_CTRL_STOP, 0); | |
205 | ||
206 | return ret; | |
207 | } | |
208 | ||
209 | /** | |
210 | * rx6110_get_time - get the current time from the rx6110 registers | |
211 | * @dev: the rtc device in use | |
212 | * @tm: holds date and time | |
213 | */ | |
214 | static int rx6110_get_time(struct device *dev, struct rtc_time *tm) | |
215 | { | |
216 | struct rx6110_data *rx6110 = dev_get_drvdata(dev); | |
217 | u8 data[RTC_NR_TIME]; | |
218 | int flags; | |
219 | int ret; | |
220 | ||
221 | ret = regmap_read(rx6110->regmap, RX6110_REG_FLAG, &flags); | |
222 | if (ret) | |
223 | return -EINVAL; | |
224 | ||
225 | /* check for VLF Flag (set at power-on) */ | |
226 | if ((flags & RX6110_BIT_FLAG_VLF)) { | |
227 | dev_warn(dev, "Voltage low, data is invalid.\n"); | |
228 | return -EINVAL; | |
229 | } | |
230 | ||
231 | /* read registers to date */ | |
232 | ret = regmap_bulk_read(rx6110->regmap, RX6110_REG_SEC, data, | |
233 | RTC_NR_TIME); | |
234 | if (ret) | |
235 | return ret; | |
236 | ||
237 | ret = rx6110_data_to_rtc_tm(data, tm); | |
238 | if (ret) | |
239 | return ret; | |
240 | ||
a3f60bb3 | 241 | dev_dbg(dev, "%s: date %ptRr\n", __func__, tm); |
68298c2d | 242 | |
22652ba7 | 243 | return 0; |
68298c2d ST |
244 | } |
245 | ||
246 | static const struct reg_sequence rx6110_default_regs[] = { | |
247 | { RX6110_REG_RES1, 0xB8 }, | |
248 | { RX6110_REG_RES2, 0x00 }, | |
249 | { RX6110_REG_RES3, 0x10 }, | |
250 | { RX6110_REG_IRQ, 0x00 }, | |
251 | { RX6110_REG_ALMIN, 0x00 }, | |
252 | { RX6110_REG_ALHOUR, 0x00 }, | |
253 | { RX6110_REG_ALWDAY, 0x00 }, | |
254 | }; | |
255 | ||
256 | /** | |
257 | * rx6110_init - initialize the rx6110 registers | |
258 | * | |
259 | * @rx6110: pointer to the rx6110 struct in use | |
260 | * | |
261 | */ | |
262 | static int rx6110_init(struct rx6110_data *rx6110) | |
263 | { | |
264 | struct rtc_device *rtc = rx6110->rtc; | |
265 | int flags; | |
266 | int ret; | |
267 | ||
268 | ret = regmap_update_bits(rx6110->regmap, RX6110_REG_EXT, | |
269 | RX6110_BIT_EXT_TE, 0); | |
270 | if (ret) | |
271 | return ret; | |
272 | ||
273 | ret = regmap_register_patch(rx6110->regmap, rx6110_default_regs, | |
274 | ARRAY_SIZE(rx6110_default_regs)); | |
275 | if (ret) | |
276 | return ret; | |
277 | ||
278 | ret = regmap_read(rx6110->regmap, RX6110_REG_FLAG, &flags); | |
279 | if (ret) | |
280 | return ret; | |
281 | ||
282 | /* check for VLF Flag (set at power-on) */ | |
283 | if ((flags & RX6110_BIT_FLAG_VLF)) | |
284 | dev_warn(&rtc->dev, "Voltage low, data loss detected.\n"); | |
285 | ||
286 | /* check for Alarm Flag */ | |
287 | if (flags & RX6110_BIT_FLAG_AF) | |
288 | dev_warn(&rtc->dev, "An alarm may have been missed.\n"); | |
289 | ||
290 | /* check for Periodic Timer Flag */ | |
291 | if (flags & RX6110_BIT_FLAG_TF) | |
292 | dev_warn(&rtc->dev, "Periodic timer was detected\n"); | |
293 | ||
294 | /* check for Update Timer Flag */ | |
295 | if (flags & RX6110_BIT_FLAG_UF) | |
296 | dev_warn(&rtc->dev, "Update timer was detected\n"); | |
297 | ||
298 | /* clear all flags BUT VLF */ | |
299 | ret = regmap_update_bits(rx6110->regmap, RX6110_REG_FLAG, | |
300 | RX6110_BIT_FLAG_AF | | |
301 | RX6110_BIT_FLAG_UF | | |
302 | RX6110_BIT_FLAG_TF, | |
303 | 0); | |
304 | ||
305 | return ret; | |
306 | } | |
307 | ||
34c7b3ac | 308 | static const struct rtc_class_ops rx6110_rtc_ops = { |
68298c2d ST |
309 | .read_time = rx6110_get_time, |
310 | .set_time = rx6110_set_time, | |
311 | }; | |
312 | ||
313 | static struct regmap_config regmap_spi_config = { | |
314 | .reg_bits = 8, | |
315 | .val_bits = 8, | |
316 | .max_register = RX6110_REG_IRQ, | |
317 | .read_flag_mask = 0x80, | |
318 | }; | |
319 | ||
320 | /** | |
321 | * rx6110_probe - initialize rtc driver | |
322 | * @spi: pointer to spi device | |
323 | */ | |
324 | static int rx6110_probe(struct spi_device *spi) | |
325 | { | |
326 | struct rx6110_data *rx6110; | |
327 | int err; | |
328 | ||
329 | if ((spi->bits_per_word && spi->bits_per_word != 8) || | |
330 | (spi->max_speed_hz > 2000000) || | |
331 | (spi->mode != (SPI_CS_HIGH | SPI_CPOL | SPI_CPHA))) { | |
332 | dev_warn(&spi->dev, "SPI settings: bits_per_word: %d, max_speed_hz: %d, mode: %xh\n", | |
333 | spi->bits_per_word, spi->max_speed_hz, spi->mode); | |
334 | dev_warn(&spi->dev, "driving device in an unsupported mode"); | |
335 | } | |
336 | ||
337 | rx6110 = devm_kzalloc(&spi->dev, sizeof(*rx6110), GFP_KERNEL); | |
338 | if (!rx6110) | |
339 | return -ENOMEM; | |
340 | ||
341 | rx6110->regmap = devm_regmap_init_spi(spi, ®map_spi_config); | |
342 | if (IS_ERR(rx6110->regmap)) { | |
343 | dev_err(&spi->dev, "regmap init failed for rtc rx6110\n"); | |
344 | return PTR_ERR(rx6110->regmap); | |
345 | } | |
346 | ||
347 | spi_set_drvdata(spi, rx6110); | |
348 | ||
349 | rx6110->rtc = devm_rtc_device_register(&spi->dev, | |
350 | RX6110_DRIVER_NAME, | |
351 | &rx6110_rtc_ops, THIS_MODULE); | |
352 | ||
353 | if (IS_ERR(rx6110->rtc)) | |
354 | return PTR_ERR(rx6110->rtc); | |
355 | ||
356 | err = rx6110_init(rx6110); | |
357 | if (err) | |
358 | return err; | |
359 | ||
360 | rx6110->rtc->max_user_freq = 1; | |
361 | ||
362 | return 0; | |
363 | } | |
364 | ||
68298c2d ST |
365 | static const struct spi_device_id rx6110_id[] = { |
366 | { "rx6110", 0 }, | |
367 | { } | |
368 | }; | |
369 | MODULE_DEVICE_TABLE(spi, rx6110_id); | |
370 | ||
f9bf089a DG |
371 | static const struct of_device_id rx6110_spi_of_match[] = { |
372 | { .compatible = "epson,rx6110" }, | |
373 | { }, | |
374 | }; | |
375 | MODULE_DEVICE_TABLE(of, rx6110_spi_of_match); | |
376 | ||
68298c2d ST |
377 | static struct spi_driver rx6110_driver = { |
378 | .driver = { | |
379 | .name = RX6110_DRIVER_NAME, | |
f9bf089a | 380 | .of_match_table = of_match_ptr(rx6110_spi_of_match), |
68298c2d ST |
381 | }, |
382 | .probe = rx6110_probe, | |
68298c2d ST |
383 | .id_table = rx6110_id, |
384 | }; | |
385 | ||
386 | module_spi_driver(rx6110_driver); | |
387 | ||
388 | MODULE_AUTHOR("Val Krutov <val.krutov@erd.epson.com>"); | |
389 | MODULE_DESCRIPTION("RX-6110 SA RTC driver"); | |
390 | MODULE_LICENSE("GPL"); |