projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'for-linus' of git://git.armlinux.org.uk/~rmk/linux-arm
[linux-block.git] / drivers / rtc / rtc-rv8803.c
CommitLineData
182ae2bb 1// SPDX-License-Identifier: GPL-2.0
1e3929ef
AB		 2/*
3 * RTC driver for the Micro Crystal RV8803
4 *
5 * Copyright (C) 2015 Micro Crystal SA
7d1e5bfe 6 * Alexandre Belloni <alexandre.belloni@bootlin.com>
1e3929ef 7 *
1e3929ef
AB		 8 */
9
10#include <linux/bcd.h>
11#include <linux/bitops.h>
c27fee16 12#include <linux/bitfield.h>
a1e98e09 13#include <linux/log2.h>
1e3929ef
AB		 14#include <linux/i2c.h>
15#include <linux/interrupt.h>
16#include <linux/kernel.h>
17#include <linux/module.h>
740ad8f4 18#include <linux/of_device.h>
1e3929ef
AB		 19#include <linux/rtc.h>
20
d522649e
BT		 21#define RV8803_I2C_TRY_COUNT 4
22
1e3929ef
AB		 23#define RV8803_SEC 0x00
24#define RV8803_MIN 0x01
25#define RV8803_HOUR 0x02
26#define RV8803_WEEK 0x03
27#define RV8803_DAY 0x04
28#define RV8803_MONTH 0x05
29#define RV8803_YEAR 0x06
30#define RV8803_RAM 0x07
31#define RV8803_ALARM_MIN 0x08
32#define RV8803_ALARM_HOUR 0x09
33#define RV8803_ALARM_WEEK_OR_DAY 0x0A
34#define RV8803_EXT 0x0D
35#define RV8803_FLAG 0x0E
36#define RV8803_CTRL 0x0F
c27fee16 37#define RV8803_OSC_OFFSET 0x2C
1e3929ef
AB		 38
39#define RV8803_EXT_WADA BIT(6)
40
41#define RV8803_FLAG_V1F BIT(0)
42#define RV8803_FLAG_V2F BIT(1)
43#define RV8803_FLAG_AF BIT(3)
44#define RV8803_FLAG_TF BIT(4)
45#define RV8803_FLAG_UF BIT(5)
46
47#define RV8803_CTRL_RESET BIT(0)
48
49#define RV8803_CTRL_EIE BIT(2)
50#define RV8803_CTRL_AIE BIT(3)
51#define RV8803_CTRL_TIE BIT(4)
52#define RV8803_CTRL_UIE BIT(5)
53
c27fee16
AF		 54#define RX8803_CTRL_CSEL GENMASK(7, 6)
55
1cd71376
OR		 56#define RX8900_BACKUP_CTRL 0x18
57#define RX8900_FLAG_SWOFF BIT(2)
58#define RX8900_FLAG_VDETOFF BIT(3)
59
60enum rv8803_type {
61 rv_8803,
c27fee16 62 rx_8803,
5c0189a8 63 rx_8804,
1cd71376
OR		 64 rx_8900
65};
66
1e3929ef
AB		 67struct rv8803_data {
68 struct i2c_client *client;
69 struct rtc_device *rtc;
9d1fa4c3 70 struct mutex flags_lock;
1e3929ef 71 u8 ctrl;
8c798e1e 72 u8 backup;
e5c59423 73 u8 alarm_invalid:1;
1cd71376 74 enum rv8803_type type;
1e3929ef
AB		 75};
76
d522649e
BT		 77static int rv8803_read_reg(const struct i2c_client *client, u8 reg)
78{
79 int try = RV8803_I2C_TRY_COUNT;
80 s32 ret;
81
82 /*
83 * There is a 61µs window during which the RTC does not acknowledge I2C
84 * transfers. In that case, ensure that there are multiple attempts.
85 */
86 do
87 ret = i2c_smbus_read_byte_data(client, reg);
88 while ((ret == -ENXIO || ret == -EIO) && --try);
89 if (ret < 0)
90 dev_err(&client->dev, "Unable to read register 0x%02x\n", reg);
91
92 return ret;
93}
94
95static int rv8803_read_regs(const struct i2c_client *client,
96 u8 reg, u8 count, u8 *values)
97{
98 int try = RV8803_I2C_TRY_COUNT;
99 s32 ret;
100
101 do
102 ret = i2c_smbus_read_i2c_block_data(client, reg, count, values);
103 while ((ret == -ENXIO || ret == -EIO) && --try);
104 if (ret != count) {
105 dev_err(&client->dev,
106 "Unable to read registers 0x%02x..0x%02x\n",
107 reg, reg + count - 1);
108 return ret < 0 ? ret : -EIO;
109 }
110
111 return 0;
112}
113
114static int rv8803_write_reg(const struct i2c_client *client, u8 reg, u8 value)
115{
116 int try = RV8803_I2C_TRY_COUNT;
117 s32 ret;
118
119 do
120 ret = i2c_smbus_write_byte_data(client, reg, value);
121 while ((ret == -ENXIO || ret == -EIO) && --try);
122 if (ret)
123 dev_err(&client->dev, "Unable to write register 0x%02x\n", reg);
124
125 return ret;
126}
127
128static int rv8803_write_regs(const struct i2c_client *client,
129 u8 reg, u8 count, const u8 *values)
130{
131 int try = RV8803_I2C_TRY_COUNT;
132 s32 ret;
133
134 do
135 ret = i2c_smbus_write_i2c_block_data(client, reg, count,
136 values);
137 while ((ret == -ENXIO || ret == -EIO) && --try);
138 if (ret)
139 dev_err(&client->dev,
140 "Unable to write registers 0x%02x..0x%02x\n",
141 reg, reg + count - 1);
142
143 return ret;
144}
145
c27fee16
AF		 146static int rv8803_regs_init(struct rv8803_data *rv8803)
147{
148 int ret;
149
150 ret = rv8803_write_reg(rv8803->client, RV8803_OSC_OFFSET, 0x00);
151 if (ret)
152 return ret;
153
154 ret = rv8803_write_reg(rv8803->client, RV8803_CTRL,
155 FIELD_PREP(RX8803_CTRL_CSEL, 1)); /* 2s */
156 if (ret)
157 return ret;
158
159 ret = rv8803_write_regs(rv8803->client, RV8803_ALARM_MIN, 3,
160 (u8[]){ 0, 0, 0 });
161 if (ret)
162 return ret;
163
164 return rv8803_write_reg(rv8803->client, RV8803_RAM, 0x00);
165}
166
f8176e0b
AF		 167static int rv8803_regs_configure(struct rv8803_data *rv8803);
168
e5c59423 169static int rv8803_regs_reset(struct rv8803_data *rv8803, bool full)
f8176e0b 170{
c27fee16
AF		 171 /*
172 * The RV-8803 resets all registers to POR defaults after voltage-loss,
173 * the Epson RTCs don't, so we manually reset the remainder here.
174 */
e5c59423 175 if (full || rv8803->type == rx_8803 || rv8803->type == rx_8900) {
c27fee16
AF		 176 int ret = rv8803_regs_init(rv8803);
177 if (ret)
178 return ret;
179 }
180
f8176e0b
AF		 181 return rv8803_regs_configure(rv8803);
182}
183
1e3929ef
AB		 184static irqreturn_t rv8803_handle_irq(int irq, void *dev_id)
185{
186 struct i2c_client *client = dev_id;
187 struct rv8803_data *rv8803 = i2c_get_clientdata(client);
188 unsigned long events = 0;
d522649e 189 int flags;
1e3929ef 190
9d1fa4c3 191 mutex_lock(&rv8803->flags_lock);
1e3929ef 192
d522649e 193 flags = rv8803_read_reg(client, RV8803_FLAG);
1e3929ef 194 if (flags <= 0) {
9d1fa4c3 195 mutex_unlock(&rv8803->flags_lock);
1e3929ef
AB		 196 return IRQ_NONE;
197 }
198
199 if (flags & RV8803_FLAG_V1F)
200 dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");
201
202 if (flags & RV8803_FLAG_V2F)
203 dev_warn(&client->dev, "Voltage low, data loss detected.\n");
204
205 if (flags & RV8803_FLAG_TF) {
206 flags &= ~RV8803_FLAG_TF;
207 rv8803->ctrl &= ~RV8803_CTRL_TIE;
208 events |= RTC_PF;
209 }
210
211 if (flags & RV8803_FLAG_AF) {
212 flags &= ~RV8803_FLAG_AF;
213 rv8803->ctrl &= ~RV8803_CTRL_AIE;
214 events |= RTC_AF;
215 }
216
217 if (flags & RV8803_FLAG_UF) {
218 flags &= ~RV8803_FLAG_UF;
219 rv8803->ctrl &= ~RV8803_CTRL_UIE;
220 events |= RTC_UF;
221 }
222
223 if (events) {
224 rtc_update_irq(rv8803->rtc, 1, events);
d522649e
BT		 225 rv8803_write_reg(client, RV8803_FLAG, flags);
226 rv8803_write_reg(rv8803->client, RV8803_CTRL, rv8803->ctrl);
1e3929ef
AB		 227 }
228
9d1fa4c3 229 mutex_unlock(&rv8803->flags_lock);
1e3929ef
AB		 230
231 return IRQ_HANDLED;
232}
233
234static int rv8803_get_time(struct device *dev, struct rtc_time *tm)
235{
236 struct rv8803_data *rv8803 = dev_get_drvdata(dev);
237 u8 date1[7];
238 u8 date2[7];
239 u8 *date = date1;
240 int ret, flags;
241
e5c59423
SH		 242 if (rv8803->alarm_invalid) {
243 dev_warn(dev, "Corruption detected, data may be invalid.\n");
244 return -EINVAL;
245 }
246
d522649e 247 flags = rv8803_read_reg(rv8803->client, RV8803_FLAG);
1e3929ef
AB		 248 if (flags < 0)
249 return flags;
250
251 if (flags & RV8803_FLAG_V2F) {
252 dev_warn(dev, "Voltage low, data is invalid.\n");
253 return -EINVAL;
254 }
255
d522649e
BT		 256 ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date);
257 if (ret)
258 return ret;
1e3929ef
AB		 259
260 if ((date1[RV8803_SEC] & 0x7f) == bin2bcd(59)) {
d522649e
BT		 261 ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date2);
262 if (ret)
263 return ret;
1e3929ef
AB		 264
265 if ((date2[RV8803_SEC] & 0x7f) != bin2bcd(59))
266 date = date2;
267 }
268
269 tm->tm_sec = bcd2bin(date[RV8803_SEC] & 0x7f);
270 tm->tm_min = bcd2bin(date[RV8803_MIN] & 0x7f);
271 tm->tm_hour = bcd2bin(date[RV8803_HOUR] & 0x3f);
a1e98e09 272 tm->tm_wday = ilog2(date[RV8803_WEEK] & 0x7f);
1e3929ef
AB		 273 tm->tm_mday = bcd2bin(date[RV8803_DAY] & 0x3f);
274 tm->tm_mon = bcd2bin(date[RV8803_MONTH] & 0x1f) - 1;
275 tm->tm_year = bcd2bin(date[RV8803_YEAR]) + 100;
276
96acb25c 277 return 0;
1e3929ef
AB		 278}
279
280static int rv8803_set_time(struct device *dev, struct rtc_time *tm)
281{
282 struct rv8803_data *rv8803 = dev_get_drvdata(dev);
283 u8 date[7];
d3700b6b 284 int ctrl, flags, ret;
1e3929ef 285
d3700b6b
BT		 286 ctrl = rv8803_read_reg(rv8803->client, RV8803_CTRL);
287 if (ctrl < 0)
288 return ctrl;
289
290 /* Stop the clock */
291 ret = rv8803_write_reg(rv8803->client, RV8803_CTRL,
292 ctrl | RV8803_CTRL_RESET);
293 if (ret)
294 return ret;
295
1e3929ef
AB		 296 date[RV8803_SEC] = bin2bcd(tm->tm_sec);
297 date[RV8803_MIN] = bin2bcd(tm->tm_min);
298 date[RV8803_HOUR] = bin2bcd(tm->tm_hour);
299 date[RV8803_WEEK] = 1 << (tm->tm_wday);
300 date[RV8803_DAY] = bin2bcd(tm->tm_mday);
301 date[RV8803_MONTH] = bin2bcd(tm->tm_mon + 1);
302 date[RV8803_YEAR] = bin2bcd(tm->tm_year - 100);
303
d522649e
BT		 304 ret = rv8803_write_regs(rv8803->client, RV8803_SEC, 7, date);
305 if (ret)
1e3929ef
AB		 306 return ret;
307
d3700b6b
BT		 308 /* Restart the clock */
309 ret = rv8803_write_reg(rv8803->client, RV8803_CTRL,
310 ctrl & ~RV8803_CTRL_RESET);
311 if (ret)
312 return ret;
313
9d1fa4c3 314 mutex_lock(&rv8803->flags_lock);
1e3929ef 315
d522649e 316 flags = rv8803_read_reg(rv8803->client, RV8803_FLAG);
1e3929ef 317 if (flags < 0) {
9d1fa4c3 318 mutex_unlock(&rv8803->flags_lock);
1e3929ef
AB		 319 return flags;
320 }
321
e5c59423
SH		 322 if ((flags & RV8803_FLAG_V2F) || rv8803->alarm_invalid) {
323 /*
324 * If we sense corruption in the alarm registers, but see no
325 * voltage loss flag, we can't rely on other registers having
326 * sensible values. Reset them fully.
327 */
328 ret = rv8803_regs_reset(rv8803, rv8803->alarm_invalid);
bb42b7e9
YY		 329 if (ret) {
330 mutex_unlock(&rv8803->flags_lock);
f8176e0b 331 return ret;
bb42b7e9 332 }
e5c59423
SH		 333
334 rv8803->alarm_invalid = false;
f8176e0b
AF		 335 }
336
d522649e 337 ret = rv8803_write_reg(rv8803->client, RV8803_FLAG,
6f367788 338 flags & ~(RV8803_FLAG_V1F | RV8803_FLAG_V2F));
1e3929ef 339
9d1fa4c3 340 mutex_unlock(&rv8803->flags_lock);
1e3929ef
AB		 341
342 return ret;
343}
344
345static int rv8803_get_alarm(struct device *dev, struct rtc_wkalrm *alrm)
346{
347 struct rv8803_data *rv8803 = dev_get_drvdata(dev);
348 struct i2c_client *client = rv8803->client;
349 u8 alarmvals[3];
350 int flags, ret;
351
d522649e
BT		 352 ret = rv8803_read_regs(client, RV8803_ALARM_MIN, 3, alarmvals);
353 if (ret)
354 return ret;
1e3929ef 355
d522649e 356 flags = rv8803_read_reg(client, RV8803_FLAG);
1e3929ef
AB		 357 if (flags < 0)
358 return flags;
359
e5c59423
SH		 360 alarmvals[0] &= 0x7f;
361 alarmvals[1] &= 0x3f;
362 alarmvals[2] &= 0x3f;
363
364 if (!bcd_is_valid(alarmvals[0]) ||
365 !bcd_is_valid(alarmvals[1]) ||
366 !bcd_is_valid(alarmvals[2]))
367 goto err_invalid;
368
1e3929ef 369 alrm->time.tm_sec = 0;
e5c59423
SH		 370 alrm->time.tm_min = bcd2bin(alarmvals[0]);
371 alrm->time.tm_hour = bcd2bin(alarmvals[1]);
372 alrm->time.tm_mday = bcd2bin(alarmvals[2]);
1e3929ef
AB		 373
374 alrm->enabled = !!(rv8803->ctrl & RV8803_CTRL_AIE);
375 alrm->pending = (flags & RV8803_FLAG_AF) && alrm->enabled;
376
e5c59423
SH		 377 if ((unsigned int)alrm->time.tm_mday > 31 ||
378 (unsigned int)alrm->time.tm_hour >= 24 ||
379 (unsigned int)alrm->time.tm_min >= 60)
380 goto err_invalid;
381
1e3929ef 382 return 0;
e5c59423
SH		 383
384err_invalid:
385 rv8803->alarm_invalid = true;
386 return -EINVAL;
1e3929ef
AB		 387}
388
389static int rv8803_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
390{
391 struct i2c_client *client = to_i2c_client(dev);
392 struct rv8803_data *rv8803 = dev_get_drvdata(dev);
393 u8 alarmvals[3];
394 u8 ctrl[2];
395 int ret, err;
1e3929ef
AB		 396
397 /* The alarm has no seconds, round up to nearest minute */
398 if (alrm->time.tm_sec) {
399 time64_t alarm_time = rtc_tm_to_time64(&alrm->time);
400
401 alarm_time += 60 - alrm->time.tm_sec;
402 rtc_time64_to_tm(alarm_time, &alrm->time);
403 }
404
9d1fa4c3 405 mutex_lock(&rv8803->flags_lock);
1e3929ef 406
d522649e
BT		 407 ret = rv8803_read_regs(client, RV8803_FLAG, 2, ctrl);
408 if (ret) {
9d1fa4c3 409 mutex_unlock(&rv8803->flags_lock);
d522649e 410 return ret;
1e3929ef
AB		 411 }
412
413 alarmvals[0] = bin2bcd(alrm->time.tm_min);
414 alarmvals[1] = bin2bcd(alrm->time.tm_hour);
415 alarmvals[2] = bin2bcd(alrm->time.tm_mday);
416
417 if (rv8803->ctrl & (RV8803_CTRL_AIE | RV8803_CTRL_UIE)) {
418 rv8803->ctrl &= ~(RV8803_CTRL_AIE | RV8803_CTRL_UIE);
d522649e
BT		 419 err = rv8803_write_reg(rv8803->client, RV8803_CTRL,
420 rv8803->ctrl);
1e3929ef 421 if (err) {
9d1fa4c3 422 mutex_unlock(&rv8803->flags_lock);
1e3929ef
AB		 423 return err;
424 }
425 }
426
03a86cda
DM		 427 ctrl[0] &= ~RV8803_FLAG_AF;
428 err = rv8803_write_reg(rv8803->client, RV8803_FLAG, ctrl[0]);
9d1fa4c3 429 mutex_unlock(&rv8803->flags_lock);
1e3929ef
AB		 430 if (err)
431 return err;
432
d522649e 433 err = rv8803_write_regs(rv8803->client, RV8803_ALARM_MIN, 3, alarmvals);
1e3929ef
AB		 434 if (err)
435 return err;
436
437 if (alrm->enabled) {
438 if (rv8803->rtc->uie_rtctimer.enabled)
439 rv8803->ctrl |= RV8803_CTRL_UIE;
440 if (rv8803->rtc->aie_timer.enabled)
441 rv8803->ctrl |= RV8803_CTRL_AIE;
442
d522649e
BT		 443 err = rv8803_write_reg(rv8803->client, RV8803_CTRL,
444 rv8803->ctrl);
1e3929ef
AB		 445 if (err)
446 return err;
447 }
448
449 return 0;
450}
451
452static int rv8803_alarm_irq_enable(struct device *dev, unsigned int enabled)
453{
454 struct i2c_client *client = to_i2c_client(dev);
455 struct rv8803_data *rv8803 = dev_get_drvdata(dev);
456 int ctrl, flags, err;
1e3929ef
AB		 457
458 ctrl = rv8803->ctrl;
459
460 if (enabled) {
461 if (rv8803->rtc->uie_rtctimer.enabled)
462 ctrl |= RV8803_CTRL_UIE;
463 if (rv8803->rtc->aie_timer.enabled)
464 ctrl |= RV8803_CTRL_AIE;
465 } else {
466 if (!rv8803->rtc->uie_rtctimer.enabled)
467 ctrl &= ~RV8803_CTRL_UIE;
468 if (!rv8803->rtc->aie_timer.enabled)
469 ctrl &= ~RV8803_CTRL_AIE;
470 }
471
9d1fa4c3 472 mutex_lock(&rv8803->flags_lock);
d522649e 473 flags = rv8803_read_reg(client, RV8803_FLAG);
1e3929ef 474 if (flags < 0) {
9d1fa4c3 475 mutex_unlock(&rv8803->flags_lock);
1e3929ef
AB		 476 return flags;
477 }
478 flags &= ~(RV8803_FLAG_AF | RV8803_FLAG_UF);
d522649e 479 err = rv8803_write_reg(client, RV8803_FLAG, flags);
9d1fa4c3 480 mutex_unlock(&rv8803->flags_lock);
1e3929ef
AB		 481 if (err)
482 return err;
483
484 if (ctrl != rv8803->ctrl) {
485 rv8803->ctrl = ctrl;
d522649e 486 err = rv8803_write_reg(client, RV8803_CTRL, rv8803->ctrl);
1e3929ef
AB		 487 if (err)
488 return err;
489 }
490
491 return 0;
492}
493
494static int rv8803_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
495{
496 struct i2c_client *client = to_i2c_client(dev);
497 struct rv8803_data *rv8803 = dev_get_drvdata(dev);
bcd17c50 498 unsigned int vl = 0;
1e3929ef 499 int flags, ret = 0;
1e3929ef
AB		 500
501 switch (cmd) {
502 case RTC_VL_READ:
d522649e 503 flags = rv8803_read_reg(client, RV8803_FLAG);
1e3929ef
AB		 504 if (flags < 0)
505 return flags;
506
bcd17c50 507 if (flags & RV8803_FLAG_V1F) {
1e3929ef 508 dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");
bcd17c50
AB		 509 vl = RTC_VL_ACCURACY_LOW;
510 }
1e3929ef
AB		 511
512 if (flags & RV8803_FLAG_V2F)
bcd17c50 513 vl |= RTC_VL_DATA_INVALID;
1e3929ef 514
bcd17c50 515 return put_user(vl, (unsigned int __user *)arg);
1e3929ef
AB		 516
517 case RTC_VL_CLR:
9d1fa4c3 518 mutex_lock(&rv8803->flags_lock);
d522649e 519 flags = rv8803_read_reg(client, RV8803_FLAG);
1e3929ef 520 if (flags < 0) {
9d1fa4c3 521 mutex_unlock(&rv8803->flags_lock);
1e3929ef
AB		 522 return flags;
523 }
524
7e890a0f 525 flags &= ~RV8803_FLAG_V1F;
d522649e 526 ret = rv8803_write_reg(client, RV8803_FLAG, flags);
9d1fa4c3 527 mutex_unlock(&rv8803->flags_lock);
d522649e 528 if (ret)
1e3929ef
AB		 529 return ret;
530
531 return 0;
532
533 default:
534 return -ENOIOCTLCMD;
535 }
536}
537
16d70a78
AB		 538static int rv8803_nvram_write(void *priv, unsigned int offset, void *val,
539 size_t bytes)
1e3929ef 540{
179b4bcc 541 return rv8803_write_reg(priv, RV8803_RAM, *(u8 *)val);
1e3929ef
AB		 542}
543
16d70a78
AB		 544static int rv8803_nvram_read(void *priv, unsigned int offset,
545 void *val, size_t bytes)
1e3929ef 546{
1e3929ef
AB		 547 int ret;
548
16d70a78 549 ret = rv8803_read_reg(priv, RV8803_RAM);
1e3929ef
AB		 550 if (ret < 0)
551 return ret;
552
16d70a78 553 *(u8 *)val = ret;
1e3929ef 554
16d70a78 555 return 0;
1e3929ef
AB		 556}
557
45909e5c 558static const struct rtc_class_ops rv8803_rtc_ops = {
1e3929ef
AB		 559 .read_time = rv8803_get_time,
560 .set_time = rv8803_set_time,
561 .ioctl = rv8803_ioctl,
45909e5c
AB		 562 .read_alarm = rv8803_get_alarm,
563 .set_alarm = rv8803_set_alarm,
564 .alarm_irq_enable = rv8803_alarm_irq_enable,
1e3929ef
AB		 565};
566
1cd71376
OR		 567static int rx8900_trickle_charger_init(struct rv8803_data *rv8803)
568{
569 struct i2c_client *client = rv8803->client;
570 struct device_node *node = client->dev.of_node;
571 int err;
572 u8 flags;
573
574 if (!node)
575 return 0;
576
577 if (rv8803->type != rx_8900)
578 return 0;
579
580 err = i2c_smbus_read_byte_data(rv8803->client, RX8900_BACKUP_CTRL);
581 if (err < 0)
582 return err;
583
8c798e1e
AF		 584 flags = (u8)err;
585 flags &= ~(RX8900_FLAG_VDETOFF | RX8900_FLAG_SWOFF);
586 flags |= rv8803->backup;
1cd71376
OR		 587
588 return i2c_smbus_write_byte_data(rv8803->client, RX8900_BACKUP_CTRL,
589 flags);
590}
591
8c798e1e
AF		 592/* configure registers with values different than the Power-On reset defaults */
593static int rv8803_regs_configure(struct rv8803_data *rv8803)
594{
595 int err;
596
597 err = rv8803_write_reg(rv8803->client, RV8803_EXT, RV8803_EXT_WADA);
598 if (err)
599 return err;
600
601 err = rx8900_trickle_charger_init(rv8803);
602 if (err) {
603 dev_err(&rv8803->client->dev, "failed to init charger\n");
604 return err;
605 }
606
607 return 0;
608}
609
84c2fb38
UKK		 610static const struct i2c_device_id rv8803_id[] = {
611 { "rv8803", rv_8803 },
612 { "rv8804", rx_8804 },
613 { "rx8803", rx_8803 },
614 { "rx8900", rx_8900 },
615 { }
616};
617MODULE_DEVICE_TABLE(i2c, rv8803_id);
618
619static int rv8803_probe(struct i2c_client *client)
1e3929ef 620{
5cb17269 621 struct i2c_adapter *adapter = client->adapter;
1e3929ef 622 struct rv8803_data *rv8803;
d522649e 623 int err, flags;
c07fd9de
AB		 624 struct nvmem_config nvmem_cfg = {
625 .name = "rv8803_nvram",
626 .word_size = 1,
627 .stride = 1,
628 .size = 1,
629 .reg_read = rv8803_nvram_read,
630 .reg_write = rv8803_nvram_write,
631 .priv = client,
632 };
1e3929ef
AB		 633
634 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
635 I2C_FUNC_SMBUS_I2C_BLOCK)) {
636 dev_err(&adapter->dev, "doesn't support I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK\n");
637 return -EIO;
638 }
639
640 rv8803 = devm_kzalloc(&client->dev, sizeof(struct rv8803_data),
641 GFP_KERNEL);
642 if (!rv8803)
643 return -ENOMEM;
644
9d1fa4c3 645 mutex_init(&rv8803->flags_lock);
1e3929ef 646 rv8803->client = client;
84c2fb38 647 if (client->dev.of_node) {
740ad8f4
JMC		 648 rv8803->type = (enum rv8803_type)
649 of_device_get_match_data(&client->dev);
84c2fb38
UKK		 650 } else {
651 const struct i2c_device_id *id = i2c_match_id(rv8803_id, client);
652
740ad8f4 653 rv8803->type = id->driver_data;
84c2fb38 654 }
1e3929ef
AB		 655 i2c_set_clientdata(client, rv8803);
656
d522649e 657 flags = rv8803_read_reg(client, RV8803_FLAG);
1e3929ef
AB		 658 if (flags < 0)
659 return flags;
660
661 if (flags & RV8803_FLAG_V1F)
662 dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");
663
664 if (flags & RV8803_FLAG_V2F)
665 dev_warn(&client->dev, "Voltage low, data loss detected.\n");
666
667 if (flags & RV8803_FLAG_AF)
668 dev_warn(&client->dev, "An alarm maybe have been missed.\n");
669
7133eca1 670 rv8803->rtc = devm_rtc_allocate_device(&client->dev);
44c638ce 671 if (IS_ERR(rv8803->rtc))
7133eca1 672 return PTR_ERR(rv8803->rtc);
7133eca1 673
1e3929ef 674 if (client->irq > 0) {
11bfd6fc
AB		 675 unsigned long irqflags = IRQF_TRIGGER_LOW;
676
677 if (dev_fwnode(&client->dev))
678 irqflags = 0;
679
1e3929ef
AB		 680 err = devm_request_threaded_irq(&client->dev, client->irq,
681 NULL, rv8803_handle_irq,
11bfd6fc 682 irqflags | IRQF_ONESHOT,
1e3929ef
AB		 683 "rv8803", client);
684 if (err) {
685 dev_warn(&client->dev, "unable to request IRQ, alarms disabled\n");
686 client->irq = 0;
1e3929ef
AB		 687 }
688 }
45909e5c
AB		 689 if (!client->irq)
690 clear_bit(RTC_FEATURE_ALARM, rv8803->rtc->features);
1e3929ef 691
8c798e1e
AF		 692 if (of_property_read_bool(client->dev.of_node, "epson,vdet-disable"))
693 rv8803->backup |= RX8900_FLAG_VDETOFF;
1e3929ef 694
8c798e1e
AF		 695 if (of_property_read_bool(client->dev.of_node, "trickle-diode-disable"))
696 rv8803->backup |= RX8900_FLAG_SWOFF;
697
698 err = rv8803_regs_configure(rv8803);
699 if (err)
1cd71376 700 return err;
1cd71376 701
ce1ae8eb 702 rv8803->rtc->ops = &rv8803_rtc_ops;
2e17f8b9
AB		 703 rv8803->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
704 rv8803->rtc->range_max = RTC_TIMESTAMP_END_2099;
fdcfd854 705 err = devm_rtc_register_device(rv8803->rtc);
ce1ae8eb
AB		 706 if (err)
707 return err;
708
3a905c2d 709 devm_rtc_nvmem_register(rv8803->rtc, &nvmem_cfg);
ce1ae8eb 710
1e3929ef
AB		 711 rv8803->rtc->max_user_freq = 1;
712
713 return 0;
714}
715
da826321 716static const __maybe_unused struct of_device_id rv8803_of_match[] = {
740ad8f4
JMC		 717 {
718 .compatible = "microcrystal,rv8803",
c856618d 719 .data = (void *)rv_8803
740ad8f4 720 },
ac771ed7
AB		 721 {
722 .compatible = "epson,rx8803",
c27fee16 723 .data = (void *)rx_8803
ac771ed7 724 },
5c0189a8
FE		 725 {
726 .compatible = "epson,rx8804",
727 .data = (void *)rx_8804
728 },
740ad8f4
JMC		 729 {
730 .compatible = "epson,rx8900",
731 .data = (void *)rx_8900
732 },
733 { }
734};
735MODULE_DEVICE_TABLE(of, rv8803_of_match);
736
1e3929ef
AB		 737static struct i2c_driver rv8803_driver = {
738 .driver = {
739 .name = "rtc-rv8803",
740ad8f4 740 .of_match_table = of_match_ptr(rv8803_of_match),
1e3929ef 741 },
84c2fb38 742 .probe_new = rv8803_probe,
1e3929ef
AB		 743 .id_table = rv8803_id,
744};
745module_i2c_driver(rv8803_driver);
746
7d1e5bfe 747MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@bootlin.com>");
1e3929ef
AB		 748MODULE_DESCRIPTION("Micro Crystal RV8803 RTC driver");
749MODULE_LICENSE("GPL v2");
Linux 6.x block layer and io_uring tree(s)