1 // SPDX-License-Identifier: GPL-2.0
3 * RTC driver for the Micro Crystal RV3028
5 * Copyright (C) 2019 Micro Crystal SA
7 * Alexandre Belloni <alexandre.belloni@bootlin.com>
11 #include <linux/clk-provider.h>
12 #include <linux/bcd.h>
13 #include <linux/bitops.h>
14 #include <linux/i2c.h>
15 #include <linux/interrupt.h>
16 #include <linux/kernel.h>
17 #include <linux/log2.h>
18 #include <linux/module.h>
19 #include <linux/of_device.h>
20 #include <linux/regmap.h>
21 #include <linux/rtc.h>
23 #define RV3028_SEC 0x00
24 #define RV3028_MIN 0x01
25 #define RV3028_HOUR 0x02
26 #define RV3028_WDAY 0x03
27 #define RV3028_DAY 0x04
28 #define RV3028_MONTH 0x05
29 #define RV3028_YEAR 0x06
30 #define RV3028_ALARM_MIN 0x07
31 #define RV3028_ALARM_HOUR 0x08
32 #define RV3028_ALARM_DAY 0x09
33 #define RV3028_STATUS 0x0E
34 #define RV3028_CTRL1 0x0F
35 #define RV3028_CTRL2 0x10
36 #define RV3028_EVT_CTRL 0x13
37 #define RV3028_TS_COUNT 0x14
38 #define RV3028_TS_SEC 0x15
39 #define RV3028_RAM1 0x1F
40 #define RV3028_EEPROM_ADDR 0x25
41 #define RV3028_EEPROM_DATA 0x26
42 #define RV3028_EEPROM_CMD 0x27
43 #define RV3028_CLKOUT 0x35
44 #define RV3028_OFFSET 0x36
45 #define RV3028_BACKUP 0x37
47 #define RV3028_STATUS_PORF BIT(0)
48 #define RV3028_STATUS_EVF BIT(1)
49 #define RV3028_STATUS_AF BIT(2)
50 #define RV3028_STATUS_TF BIT(3)
51 #define RV3028_STATUS_UF BIT(4)
52 #define RV3028_STATUS_BSF BIT(5)
53 #define RV3028_STATUS_CLKF BIT(6)
54 #define RV3028_STATUS_EEBUSY BIT(7)
56 #define RV3028_CLKOUT_FD_MASK GENMASK(2, 0)
57 #define RV3028_CLKOUT_PORIE BIT(3)
58 #define RV3028_CLKOUT_CLKSY BIT(6)
59 #define RV3028_CLKOUT_CLKOE BIT(7)
61 #define RV3028_CTRL1_EERD BIT(3)
62 #define RV3028_CTRL1_WADA BIT(5)
64 #define RV3028_CTRL2_RESET BIT(0)
65 #define RV3028_CTRL2_12_24 BIT(1)
66 #define RV3028_CTRL2_EIE BIT(2)
67 #define RV3028_CTRL2_AIE BIT(3)
68 #define RV3028_CTRL2_TIE BIT(4)
69 #define RV3028_CTRL2_UIE BIT(5)
70 #define RV3028_CTRL2_TSE BIT(7)
72 #define RV3028_EVT_CTRL_TSR BIT(2)
74 #define RV3028_EEPROM_CMD_UPDATE 0x11
75 #define RV3028_EEPROM_CMD_WRITE 0x21
76 #define RV3028_EEPROM_CMD_READ 0x22
78 #define RV3028_EEBUSY_POLL 10000
79 #define RV3028_EEBUSY_TIMEOUT 100000
81 #define RV3028_BACKUP_TCE BIT(5)
82 #define RV3028_BACKUP_TCR_MASK GENMASK(1,0)
84 #define OFFSET_STEP_PPT 953674
91 struct regmap
*regmap
;
92 struct rtc_device
*rtc
;
93 enum rv3028_type type
;
94 #ifdef CONFIG_COMMON_CLK
95 struct clk_hw clkout_hw
;
99 static u16 rv3028_trickle_resistors
[] = {3000, 5000, 9000, 15000};
101 static ssize_t
timestamp0_store(struct device
*dev
,
102 struct device_attribute
*attr
,
103 const char *buf
, size_t count
)
105 struct rv3028_data
*rv3028
= dev_get_drvdata(dev
->parent
);
107 regmap_update_bits(rv3028
->regmap
, RV3028_EVT_CTRL
, RV3028_EVT_CTRL_TSR
,
108 RV3028_EVT_CTRL_TSR
);
113 static ssize_t
timestamp0_show(struct device
*dev
,
114 struct device_attribute
*attr
, char *buf
)
116 struct rv3028_data
*rv3028
= dev_get_drvdata(dev
->parent
);
121 ret
= regmap_read(rv3028
->regmap
, RV3028_TS_COUNT
, &count
);
128 ret
= regmap_bulk_read(rv3028
->regmap
, RV3028_TS_SEC
, date
,
133 tm
.tm_sec
= bcd2bin(date
[0]);
134 tm
.tm_min
= bcd2bin(date
[1]);
135 tm
.tm_hour
= bcd2bin(date
[2]);
136 tm
.tm_mday
= bcd2bin(date
[3]);
137 tm
.tm_mon
= bcd2bin(date
[4]) - 1;
138 tm
.tm_year
= bcd2bin(date
[5]) + 100;
140 ret
= rtc_valid_tm(&tm
);
144 return sprintf(buf
, "%llu\n",
145 (unsigned long long)rtc_tm_to_time64(&tm
));
148 static DEVICE_ATTR_RW(timestamp0
);
150 static ssize_t
timestamp0_count_show(struct device
*dev
,
151 struct device_attribute
*attr
, char *buf
)
153 struct rv3028_data
*rv3028
= dev_get_drvdata(dev
->parent
);
156 ret
= regmap_read(rv3028
->regmap
, RV3028_TS_COUNT
, &count
);
160 return sprintf(buf
, "%u\n", count
);
163 static DEVICE_ATTR_RO(timestamp0_count
);
165 static struct attribute
*rv3028_attrs
[] = {
166 &dev_attr_timestamp0
.attr
,
167 &dev_attr_timestamp0_count
.attr
,
171 static const struct attribute_group rv3028_attr_group
= {
172 .attrs
= rv3028_attrs
,
175 static int rv3028_exit_eerd(struct rv3028_data
*rv3028
, u32 eerd
)
180 return regmap_update_bits(rv3028
->regmap
, RV3028_CTRL1
, RV3028_CTRL1_EERD
, 0);
183 static int rv3028_enter_eerd(struct rv3028_data
*rv3028
, u32
*eerd
)
188 ret
= regmap_read(rv3028
->regmap
, RV3028_CTRL1
, &ctrl1
);
192 *eerd
= ctrl1
& RV3028_CTRL1_EERD
;
196 ret
= regmap_update_bits(rv3028
->regmap
, RV3028_CTRL1
,
197 RV3028_CTRL1_EERD
, RV3028_CTRL1_EERD
);
201 ret
= regmap_read_poll_timeout(rv3028
->regmap
, RV3028_STATUS
, status
,
202 !(status
& RV3028_STATUS_EEBUSY
),
203 RV3028_EEBUSY_POLL
, RV3028_EEBUSY_TIMEOUT
);
205 rv3028_exit_eerd(rv3028
, *eerd
);
213 static int rv3028_update_eeprom(struct rv3028_data
*rv3028
, u32 eerd
)
218 ret
= regmap_write(rv3028
->regmap
, RV3028_EEPROM_CMD
, 0x0);
222 ret
= regmap_write(rv3028
->regmap
, RV3028_EEPROM_CMD
, RV3028_EEPROM_CMD_UPDATE
);
226 usleep_range(63000, RV3028_EEBUSY_TIMEOUT
);
228 ret
= regmap_read_poll_timeout(rv3028
->regmap
, RV3028_STATUS
, status
,
229 !(status
& RV3028_STATUS_EEBUSY
),
230 RV3028_EEBUSY_POLL
, RV3028_EEBUSY_TIMEOUT
);
233 rv3028_exit_eerd(rv3028
, eerd
);
238 static int rv3028_update_cfg(struct rv3028_data
*rv3028
, unsigned int reg
,
239 unsigned int mask
, unsigned int val
)
244 ret
= rv3028_enter_eerd(rv3028
, &eerd
);
248 ret
= regmap_update_bits(rv3028
->regmap
, reg
, mask
, val
);
250 rv3028_exit_eerd(rv3028
, eerd
);
254 return rv3028_update_eeprom(rv3028
, eerd
);
257 static irqreturn_t
rv3028_handle_irq(int irq
, void *dev_id
)
259 struct rv3028_data
*rv3028
= dev_id
;
260 unsigned long events
= 0;
261 u32 status
= 0, ctrl
= 0;
263 if (regmap_read(rv3028
->regmap
, RV3028_STATUS
, &status
) < 0 ||
268 status
&= ~RV3028_STATUS_PORF
;
270 if (status
& RV3028_STATUS_TF
) {
271 status
|= RV3028_STATUS_TF
;
272 ctrl
|= RV3028_CTRL2_TIE
;
276 if (status
& RV3028_STATUS_AF
) {
277 status
|= RV3028_STATUS_AF
;
278 ctrl
|= RV3028_CTRL2_AIE
;
282 if (status
& RV3028_STATUS_UF
) {
283 status
|= RV3028_STATUS_UF
;
284 ctrl
|= RV3028_CTRL2_UIE
;
289 rtc_update_irq(rv3028
->rtc
, 1, events
);
290 regmap_update_bits(rv3028
->regmap
, RV3028_STATUS
, status
, 0);
291 regmap_update_bits(rv3028
->regmap
, RV3028_CTRL2
, ctrl
, 0);
294 if (status
& RV3028_STATUS_EVF
) {
295 sysfs_notify(&rv3028
->rtc
->dev
.kobj
, NULL
,
296 dev_attr_timestamp0
.attr
.name
);
297 dev_warn(&rv3028
->rtc
->dev
, "event detected");
303 static int rv3028_get_time(struct device
*dev
, struct rtc_time
*tm
)
305 struct rv3028_data
*rv3028
= dev_get_drvdata(dev
);
309 ret
= regmap_read(rv3028
->regmap
, RV3028_STATUS
, &status
);
313 if (status
& RV3028_STATUS_PORF
)
316 ret
= regmap_bulk_read(rv3028
->regmap
, RV3028_SEC
, date
, sizeof(date
));
320 tm
->tm_sec
= bcd2bin(date
[RV3028_SEC
] & 0x7f);
321 tm
->tm_min
= bcd2bin(date
[RV3028_MIN
] & 0x7f);
322 tm
->tm_hour
= bcd2bin(date
[RV3028_HOUR
] & 0x3f);
323 tm
->tm_wday
= date
[RV3028_WDAY
] & 0x7f;
324 tm
->tm_mday
= bcd2bin(date
[RV3028_DAY
] & 0x3f);
325 tm
->tm_mon
= bcd2bin(date
[RV3028_MONTH
] & 0x1f) - 1;
326 tm
->tm_year
= bcd2bin(date
[RV3028_YEAR
]) + 100;
331 static int rv3028_set_time(struct device
*dev
, struct rtc_time
*tm
)
333 struct rv3028_data
*rv3028
= dev_get_drvdata(dev
);
337 date
[RV3028_SEC
] = bin2bcd(tm
->tm_sec
);
338 date
[RV3028_MIN
] = bin2bcd(tm
->tm_min
);
339 date
[RV3028_HOUR
] = bin2bcd(tm
->tm_hour
);
340 date
[RV3028_WDAY
] = tm
->tm_wday
;
341 date
[RV3028_DAY
] = bin2bcd(tm
->tm_mday
);
342 date
[RV3028_MONTH
] = bin2bcd(tm
->tm_mon
+ 1);
343 date
[RV3028_YEAR
] = bin2bcd(tm
->tm_year
- 100);
346 * Writing to the Seconds register has the same effect as setting RESET
349 ret
= regmap_bulk_write(rv3028
->regmap
, RV3028_SEC
, date
,
354 ret
= regmap_update_bits(rv3028
->regmap
, RV3028_STATUS
,
355 RV3028_STATUS_PORF
, 0);
360 static int rv3028_get_alarm(struct device
*dev
, struct rtc_wkalrm
*alrm
)
362 struct rv3028_data
*rv3028
= dev_get_drvdata(dev
);
364 int status
, ctrl
, ret
;
366 ret
= regmap_bulk_read(rv3028
->regmap
, RV3028_ALARM_MIN
, alarmvals
,
371 ret
= regmap_read(rv3028
->regmap
, RV3028_STATUS
, &status
);
375 ret
= regmap_read(rv3028
->regmap
, RV3028_CTRL2
, &ctrl
);
379 alrm
->time
.tm_sec
= 0;
380 alrm
->time
.tm_min
= bcd2bin(alarmvals
[0] & 0x7f);
381 alrm
->time
.tm_hour
= bcd2bin(alarmvals
[1] & 0x3f);
382 alrm
->time
.tm_mday
= bcd2bin(alarmvals
[2] & 0x3f);
384 alrm
->enabled
= !!(ctrl
& RV3028_CTRL2_AIE
);
385 alrm
->pending
= (status
& RV3028_STATUS_AF
) && alrm
->enabled
;
390 static int rv3028_set_alarm(struct device
*dev
, struct rtc_wkalrm
*alrm
)
392 struct rv3028_data
*rv3028
= dev_get_drvdata(dev
);
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
);
401 alarm_time
+= 60 - alrm
->time
.tm_sec
;
402 rtc_time64_to_tm(alarm_time
, &alrm
->time
);
405 ret
= regmap_update_bits(rv3028
->regmap
, RV3028_CTRL2
,
406 RV3028_CTRL2_AIE
| RV3028_CTRL2_UIE
, 0);
410 alarmvals
[0] = bin2bcd(alrm
->time
.tm_min
);
411 alarmvals
[1] = bin2bcd(alrm
->time
.tm_hour
);
412 alarmvals
[2] = bin2bcd(alrm
->time
.tm_mday
);
414 ret
= regmap_update_bits(rv3028
->regmap
, RV3028_STATUS
,
415 RV3028_STATUS_AF
, 0);
419 ret
= regmap_bulk_write(rv3028
->regmap
, RV3028_ALARM_MIN
, alarmvals
,
425 if (rv3028
->rtc
->uie_rtctimer
.enabled
)
426 ctrl
|= RV3028_CTRL2_UIE
;
427 if (rv3028
->rtc
->aie_timer
.enabled
)
428 ctrl
|= RV3028_CTRL2_AIE
;
431 ret
= regmap_update_bits(rv3028
->regmap
, RV3028_CTRL2
,
432 RV3028_CTRL2_UIE
| RV3028_CTRL2_AIE
, ctrl
);
437 static int rv3028_alarm_irq_enable(struct device
*dev
, unsigned int enabled
)
439 struct rv3028_data
*rv3028
= dev_get_drvdata(dev
);
443 if (rv3028
->rtc
->uie_rtctimer
.enabled
)
444 ctrl
|= RV3028_CTRL2_UIE
;
445 if (rv3028
->rtc
->aie_timer
.enabled
)
446 ctrl
|= RV3028_CTRL2_AIE
;
449 ret
= regmap_update_bits(rv3028
->regmap
, RV3028_STATUS
,
450 RV3028_STATUS_AF
| RV3028_STATUS_UF
, 0);
454 ret
= regmap_update_bits(rv3028
->regmap
, RV3028_CTRL2
,
455 RV3028_CTRL2_UIE
| RV3028_CTRL2_AIE
, ctrl
);
462 static int rv3028_read_offset(struct device
*dev
, long *offset
)
464 struct rv3028_data
*rv3028
= dev_get_drvdata(dev
);
465 int ret
, value
, steps
;
467 ret
= regmap_read(rv3028
->regmap
, RV3028_OFFSET
, &value
);
471 steps
= sign_extend32(value
<< 1, 8);
473 ret
= regmap_read(rv3028
->regmap
, RV3028_BACKUP
, &value
);
479 *offset
= DIV_ROUND_CLOSEST(steps
* OFFSET_STEP_PPT
, 1000);
484 static int rv3028_set_offset(struct device
*dev
, long offset
)
486 struct rv3028_data
*rv3028
= dev_get_drvdata(dev
);
490 offset
= clamp(offset
, -244141L, 243187L) * 1000;
491 offset
= DIV_ROUND_CLOSEST(offset
, OFFSET_STEP_PPT
);
493 ret
= rv3028_enter_eerd(rv3028
, &eerd
);
497 ret
= regmap_write(rv3028
->regmap
, RV3028_OFFSET
, offset
>> 1);
501 ret
= regmap_update_bits(rv3028
->regmap
, RV3028_BACKUP
, BIT(7),
506 return rv3028_update_eeprom(rv3028
, eerd
);
509 rv3028_exit_eerd(rv3028
, eerd
);
515 static int rv3028_ioctl(struct device
*dev
, unsigned int cmd
, unsigned long arg
)
517 struct rv3028_data
*rv3028
= dev_get_drvdata(dev
);
522 ret
= regmap_read(rv3028
->regmap
, RV3028_STATUS
, &status
);
526 status
= status
& RV3028_STATUS_PORF
? RTC_VL_DATA_INVALID
: 0;
527 return put_user(status
, (unsigned int __user
*)arg
);
534 static int rv3028_nvram_write(void *priv
, unsigned int offset
, void *val
,
537 return regmap_bulk_write(priv
, RV3028_RAM1
+ offset
, val
, bytes
);
540 static int rv3028_nvram_read(void *priv
, unsigned int offset
, void *val
,
543 return regmap_bulk_read(priv
, RV3028_RAM1
+ offset
, val
, bytes
);
546 static int rv3028_eeprom_write(void *priv
, unsigned int offset
, void *val
,
549 struct rv3028_data
*rv3028
= priv
;
554 ret
= rv3028_enter_eerd(rv3028
, &eerd
);
558 for (i
= 0; i
< bytes
; i
++) {
559 ret
= regmap_write(rv3028
->regmap
, RV3028_EEPROM_ADDR
, offset
+ i
);
563 ret
= regmap_write(rv3028
->regmap
, RV3028_EEPROM_DATA
, buf
[i
]);
567 ret
= regmap_write(rv3028
->regmap
, RV3028_EEPROM_CMD
, 0x0);
571 ret
= regmap_write(rv3028
->regmap
, RV3028_EEPROM_CMD
,
572 RV3028_EEPROM_CMD_WRITE
);
576 usleep_range(RV3028_EEBUSY_POLL
, RV3028_EEBUSY_TIMEOUT
);
578 ret
= regmap_read_poll_timeout(rv3028
->regmap
, RV3028_STATUS
, status
,
579 !(status
& RV3028_STATUS_EEBUSY
),
581 RV3028_EEBUSY_TIMEOUT
);
587 rv3028_exit_eerd(rv3028
, eerd
);
592 static int rv3028_eeprom_read(void *priv
, unsigned int offset
, void *val
,
595 struct rv3028_data
*rv3028
= priv
;
596 u32 status
, eerd
, data
;
600 ret
= rv3028_enter_eerd(rv3028
, &eerd
);
604 for (i
= 0; i
< bytes
; i
++) {
605 ret
= regmap_write(rv3028
->regmap
, RV3028_EEPROM_ADDR
, offset
+ i
);
609 ret
= regmap_write(rv3028
->regmap
, RV3028_EEPROM_CMD
, 0x0);
613 ret
= regmap_write(rv3028
->regmap
, RV3028_EEPROM_CMD
,
614 RV3028_EEPROM_CMD_READ
);
618 ret
= regmap_read_poll_timeout(rv3028
->regmap
, RV3028_STATUS
, status
,
619 !(status
& RV3028_STATUS_EEBUSY
),
621 RV3028_EEBUSY_TIMEOUT
);
625 ret
= regmap_read(rv3028
->regmap
, RV3028_EEPROM_DATA
, &data
);
632 rv3028_exit_eerd(rv3028
, eerd
);
637 #ifdef CONFIG_COMMON_CLK
638 #define clkout_hw_to_rv3028(hw) container_of(hw, struct rv3028_data, clkout_hw)
640 static int clkout_rates
[] = {
649 static unsigned long rv3028_clkout_recalc_rate(struct clk_hw
*hw
,
650 unsigned long parent_rate
)
653 struct rv3028_data
*rv3028
= clkout_hw_to_rv3028(hw
);
655 ret
= regmap_read(rv3028
->regmap
, RV3028_CLKOUT
, &clkout
);
659 clkout
&= RV3028_CLKOUT_FD_MASK
;
660 return clkout_rates
[clkout
];
663 static long rv3028_clkout_round_rate(struct clk_hw
*hw
, unsigned long rate
,
664 unsigned long *prate
)
668 for (i
= 0; i
< ARRAY_SIZE(clkout_rates
); i
++)
669 if (clkout_rates
[i
] <= rate
)
670 return clkout_rates
[i
];
675 static int rv3028_clkout_set_rate(struct clk_hw
*hw
, unsigned long rate
,
676 unsigned long parent_rate
)
680 struct rv3028_data
*rv3028
= clkout_hw_to_rv3028(hw
);
682 ret
= regmap_read(rv3028
->regmap
, RV3028_CLKOUT
, &enabled
);
686 ret
= regmap_write(rv3028
->regmap
, RV3028_CLKOUT
, 0x0);
690 enabled
&= RV3028_CLKOUT_CLKOE
;
692 for (i
= 0; i
< ARRAY_SIZE(clkout_rates
); i
++)
693 if (clkout_rates
[i
] == rate
)
694 return rv3028_update_cfg(rv3028
, RV3028_CLKOUT
, 0xff,
695 RV3028_CLKOUT_CLKSY
| enabled
| i
);
700 static int rv3028_clkout_prepare(struct clk_hw
*hw
)
702 struct rv3028_data
*rv3028
= clkout_hw_to_rv3028(hw
);
704 return regmap_write(rv3028
->regmap
, RV3028_CLKOUT
,
705 RV3028_CLKOUT_CLKSY
| RV3028_CLKOUT_CLKOE
);
708 static void rv3028_clkout_unprepare(struct clk_hw
*hw
)
710 struct rv3028_data
*rv3028
= clkout_hw_to_rv3028(hw
);
712 regmap_write(rv3028
->regmap
, RV3028_CLKOUT
, 0x0);
713 regmap_update_bits(rv3028
->regmap
, RV3028_STATUS
,
714 RV3028_STATUS_CLKF
, 0);
717 static int rv3028_clkout_is_prepared(struct clk_hw
*hw
)
720 struct rv3028_data
*rv3028
= clkout_hw_to_rv3028(hw
);
722 ret
= regmap_read(rv3028
->regmap
, RV3028_CLKOUT
, &clkout
);
726 return !!(clkout
& RV3028_CLKOUT_CLKOE
);
729 static const struct clk_ops rv3028_clkout_ops
= {
730 .prepare
= rv3028_clkout_prepare
,
731 .unprepare
= rv3028_clkout_unprepare
,
732 .is_prepared
= rv3028_clkout_is_prepared
,
733 .recalc_rate
= rv3028_clkout_recalc_rate
,
734 .round_rate
= rv3028_clkout_round_rate
,
735 .set_rate
= rv3028_clkout_set_rate
,
738 static int rv3028_clkout_register_clk(struct rv3028_data
*rv3028
,
739 struct i2c_client
*client
)
743 struct clk_init_data init
;
744 struct device_node
*node
= client
->dev
.of_node
;
746 ret
= regmap_update_bits(rv3028
->regmap
, RV3028_STATUS
,
747 RV3028_STATUS_CLKF
, 0);
751 init
.name
= "rv3028-clkout";
752 init
.ops
= &rv3028_clkout_ops
;
754 init
.parent_names
= NULL
;
755 init
.num_parents
= 0;
756 rv3028
->clkout_hw
.init
= &init
;
758 /* optional override of the clockname */
759 of_property_read_string(node
, "clock-output-names", &init
.name
);
761 /* register the clock */
762 clk
= devm_clk_register(&client
->dev
, &rv3028
->clkout_hw
);
764 of_clk_add_provider(node
, of_clk_src_simple_get
, clk
);
770 static const struct rtc_class_ops rv3028_rtc_ops
= {
771 .read_time
= rv3028_get_time
,
772 .set_time
= rv3028_set_time
,
773 .read_alarm
= rv3028_get_alarm
,
774 .set_alarm
= rv3028_set_alarm
,
775 .alarm_irq_enable
= rv3028_alarm_irq_enable
,
776 .read_offset
= rv3028_read_offset
,
777 .set_offset
= rv3028_set_offset
,
778 .ioctl
= rv3028_ioctl
,
781 static const struct regmap_config regmap_config
= {
784 .max_register
= 0x37,
787 static int rv3028_probe(struct i2c_client
*client
)
789 struct rv3028_data
*rv3028
;
792 struct nvmem_config nvmem_cfg
= {
793 .name
= "rv3028_nvram",
797 .type
= NVMEM_TYPE_BATTERY_BACKED
,
798 .reg_read
= rv3028_nvram_read
,
799 .reg_write
= rv3028_nvram_write
,
801 struct nvmem_config eeprom_cfg
= {
802 .name
= "rv3028_eeprom",
806 .type
= NVMEM_TYPE_EEPROM
,
807 .reg_read
= rv3028_eeprom_read
,
808 .reg_write
= rv3028_eeprom_write
,
811 rv3028
= devm_kzalloc(&client
->dev
, sizeof(struct rv3028_data
),
816 rv3028
->regmap
= devm_regmap_init_i2c(client
, ®map_config
);
817 if (IS_ERR(rv3028
->regmap
))
818 return PTR_ERR(rv3028
->regmap
);
820 i2c_set_clientdata(client
, rv3028
);
822 ret
= regmap_read(rv3028
->regmap
, RV3028_STATUS
, &status
);
826 if (status
& RV3028_STATUS_AF
)
827 dev_warn(&client
->dev
, "An alarm may have been missed.\n");
829 rv3028
->rtc
= devm_rtc_allocate_device(&client
->dev
);
830 if (IS_ERR(rv3028
->rtc
))
831 return PTR_ERR(rv3028
->rtc
);
833 if (client
->irq
> 0) {
834 ret
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
835 NULL
, rv3028_handle_irq
,
836 IRQF_TRIGGER_LOW
| IRQF_ONESHOT
,
839 dev_warn(&client
->dev
, "unable to request IRQ, alarms disabled\n");
844 clear_bit(RTC_FEATURE_ALARM
, rv3028
->rtc
->features
);
846 ret
= regmap_update_bits(rv3028
->regmap
, RV3028_CTRL1
,
847 RV3028_CTRL1_WADA
, RV3028_CTRL1_WADA
);
851 /* setup timestamping */
852 ret
= regmap_update_bits(rv3028
->regmap
, RV3028_CTRL2
,
853 RV3028_CTRL2_EIE
| RV3028_CTRL2_TSE
,
854 RV3028_CTRL2_EIE
| RV3028_CTRL2_TSE
);
858 /* setup trickle charger */
859 if (!device_property_read_u32(&client
->dev
, "trickle-resistor-ohms",
863 for (i
= 0; i
< ARRAY_SIZE(rv3028_trickle_resistors
); i
++)
864 if (ohms
== rv3028_trickle_resistors
[i
])
867 if (i
< ARRAY_SIZE(rv3028_trickle_resistors
)) {
868 ret
= rv3028_update_cfg(rv3028
, RV3028_BACKUP
, RV3028_BACKUP_TCE
|
869 RV3028_BACKUP_TCR_MASK
, RV3028_BACKUP_TCE
| i
);
873 dev_warn(&client
->dev
, "invalid trickle resistor value\n");
877 ret
= rtc_add_group(rv3028
->rtc
, &rv3028_attr_group
);
881 rv3028
->rtc
->range_min
= RTC_TIMESTAMP_BEGIN_2000
;
882 rv3028
->rtc
->range_max
= RTC_TIMESTAMP_END_2099
;
883 rv3028
->rtc
->ops
= &rv3028_rtc_ops
;
884 ret
= devm_rtc_register_device(rv3028
->rtc
);
888 nvmem_cfg
.priv
= rv3028
->regmap
;
889 devm_rtc_nvmem_register(rv3028
->rtc
, &nvmem_cfg
);
890 eeprom_cfg
.priv
= rv3028
;
891 devm_rtc_nvmem_register(rv3028
->rtc
, &eeprom_cfg
);
893 rv3028
->rtc
->max_user_freq
= 1;
895 #ifdef CONFIG_COMMON_CLK
896 rv3028_clkout_register_clk(rv3028
, client
);
901 static const __maybe_unused
struct of_device_id rv3028_of_match
[] = {
902 { .compatible
= "microcrystal,rv3028", },
905 MODULE_DEVICE_TABLE(of
, rv3028_of_match
);
907 static struct i2c_driver rv3028_driver
= {
909 .name
= "rtc-rv3028",
910 .of_match_table
= of_match_ptr(rv3028_of_match
),
912 .probe_new
= rv3028_probe
,
914 module_i2c_driver(rv3028_driver
);
916 MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@bootlin.com>");
917 MODULE_DESCRIPTION("Micro Crystal RV3028 RTC driver");
918 MODULE_LICENSE("GPL v2");