2 * Micro Crystal RV-3029 / RV-3049 rtc class driver
4 * Author: Gregory Hermant <gregory.hermant@calao-systems.com>
5 * Michael Buesch <m@bues.ch>
7 * based on previously existing rtc class drivers
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
15 #include <linux/module.h>
16 #include <linux/i2c.h>
17 #include <linux/spi/spi.h>
18 #include <linux/bcd.h>
19 #include <linux/rtc.h>
20 #include <linux/delay.h>
22 #include <linux/hwmon.h>
23 #include <linux/hwmon-sysfs.h>
24 #include <linux/regmap.h>
28 #define RV3029_ONOFF_CTRL 0x00
29 #define RV3029_ONOFF_CTRL_WE BIT(0)
30 #define RV3029_ONOFF_CTRL_TE BIT(1)
31 #define RV3029_ONOFF_CTRL_TAR BIT(2)
32 #define RV3029_ONOFF_CTRL_EERE BIT(3)
33 #define RV3029_ONOFF_CTRL_SRON BIT(4)
34 #define RV3029_ONOFF_CTRL_TD0 BIT(5)
35 #define RV3029_ONOFF_CTRL_TD1 BIT(6)
36 #define RV3029_ONOFF_CTRL_CLKINT BIT(7)
37 #define RV3029_IRQ_CTRL 0x01
38 #define RV3029_IRQ_CTRL_AIE BIT(0)
39 #define RV3029_IRQ_CTRL_TIE BIT(1)
40 #define RV3029_IRQ_CTRL_V1IE BIT(2)
41 #define RV3029_IRQ_CTRL_V2IE BIT(3)
42 #define RV3029_IRQ_CTRL_SRIE BIT(4)
43 #define RV3029_IRQ_FLAGS 0x02
44 #define RV3029_IRQ_FLAGS_AF BIT(0)
45 #define RV3029_IRQ_FLAGS_TF BIT(1)
46 #define RV3029_IRQ_FLAGS_V1IF BIT(2)
47 #define RV3029_IRQ_FLAGS_V2IF BIT(3)
48 #define RV3029_IRQ_FLAGS_SRF BIT(4)
49 #define RV3029_STATUS 0x03
50 #define RV3029_STATUS_VLOW1 BIT(2)
51 #define RV3029_STATUS_VLOW2 BIT(3)
52 #define RV3029_STATUS_SR BIT(4)
53 #define RV3029_STATUS_PON BIT(5)
54 #define RV3029_STATUS_EEBUSY BIT(7)
55 #define RV3029_RST_CTRL 0x04
56 #define RV3029_RST_CTRL_SYSR BIT(4)
57 #define RV3029_CONTROL_SECTION_LEN 0x05
60 #define RV3029_W_SEC 0x08
61 #define RV3029_W_MINUTES 0x09
62 #define RV3029_W_HOURS 0x0A
63 #define RV3029_REG_HR_12_24 BIT(6) /* 24h/12h mode */
64 #define RV3029_REG_HR_PM BIT(5) /* PM/AM bit in 12h mode */
65 #define RV3029_W_DATE 0x0B
66 #define RV3029_W_DAYS 0x0C
67 #define RV3029_W_MONTHS 0x0D
68 #define RV3029_W_YEARS 0x0E
69 #define RV3029_WATCH_SECTION_LEN 0x07
72 #define RV3029_A_SC 0x10
73 #define RV3029_A_MN 0x11
74 #define RV3029_A_HR 0x12
75 #define RV3029_A_DT 0x13
76 #define RV3029_A_DW 0x14
77 #define RV3029_A_MO 0x15
78 #define RV3029_A_YR 0x16
79 #define RV3029_ALARM_SECTION_LEN 0x07
82 #define RV3029_TIMER_LOW 0x18
83 #define RV3029_TIMER_HIGH 0x19
85 /* temperature section */
86 #define RV3029_TEMP_PAGE 0x20
88 /* eeprom data section */
89 #define RV3029_E2P_EEDATA1 0x28
90 #define RV3029_E2P_EEDATA2 0x29
91 #define RV3029_E2PDATA_SECTION_LEN 0x02
93 /* eeprom control section */
94 #define RV3029_CONTROL_E2P_EECTRL 0x30
95 #define RV3029_EECTRL_THP BIT(0) /* temp scan interval */
96 #define RV3029_EECTRL_THE BIT(1) /* thermometer enable */
97 #define RV3029_EECTRL_FD0 BIT(2) /* CLKOUT */
98 #define RV3029_EECTRL_FD1 BIT(3) /* CLKOUT */
99 #define RV3029_TRICKLE_1K BIT(4) /* 1.5K resistance */
100 #define RV3029_TRICKLE_5K BIT(5) /* 5K resistance */
101 #define RV3029_TRICKLE_20K BIT(6) /* 20K resistance */
102 #define RV3029_TRICKLE_80K BIT(7) /* 80K resistance */
103 #define RV3029_TRICKLE_MASK (RV3029_TRICKLE_1K |\
105 RV3029_TRICKLE_20K |\
107 #define RV3029_TRICKLE_SHIFT 4
108 #define RV3029_CONTROL_E2P_XOFFS 0x31 /* XTAL offset */
109 #define RV3029_CONTROL_E2P_XOFFS_SIGN BIT(7) /* Sign: 1->pos, 0->neg */
110 #define RV3029_CONTROL_E2P_QCOEF 0x32 /* XTAL temp drift coef */
111 #define RV3029_CONTROL_E2P_TURNOVER 0x33 /* XTAL turnover temp (in *C) */
112 #define RV3029_CONTROL_E2P_TOV_MASK 0x3F /* XTAL turnover temp mask */
114 /* user ram section */
115 #define RV3029_USR1_RAM_PAGE 0x38
116 #define RV3029_USR1_SECTION_LEN 0x04
117 #define RV3029_USR2_RAM_PAGE 0x3C
118 #define RV3029_USR2_SECTION_LEN 0x04
122 struct rtc_device
*rtc
;
123 struct regmap
*regmap
;
127 static int rv3029_read_regs(struct device
*dev
, u8 reg
, u8
*buf
,
130 struct rv3029_data
*rv3029
= dev_get_drvdata(dev
);
132 if ((reg
> RV3029_USR1_RAM_PAGE
+ 7) ||
133 (reg
+ len
> RV3029_USR1_RAM_PAGE
+ 8))
136 return regmap_bulk_read(rv3029
->regmap
, reg
, buf
, len
);
139 static int rv3029_write_regs(struct device
*dev
, u8 reg
, u8
const buf
[],
142 struct rv3029_data
*rv3029
= dev_get_drvdata(dev
);
144 if ((reg
> RV3029_USR1_RAM_PAGE
+ 7) ||
145 (reg
+ len
> RV3029_USR1_RAM_PAGE
+ 8))
148 return regmap_bulk_write(rv3029
->regmap
, reg
, buf
, len
);
151 static int rv3029_update_bits(struct device
*dev
, u8 reg
, u8 mask
, u8 set
)
156 ret
= rv3029_read_regs(dev
, reg
, &buf
, 1);
161 ret
= rv3029_write_regs(dev
, reg
, &buf
, 1);
168 static int rv3029_get_sr(struct device
*dev
, u8
*buf
)
170 int ret
= rv3029_read_regs(dev
, RV3029_STATUS
, buf
, 1);
174 dev_dbg(dev
, "status = 0x%.2x (%d)\n", buf
[0], buf
[0]);
178 static int rv3029_set_sr(struct device
*dev
, u8 val
)
184 sr
= rv3029_write_regs(dev
, RV3029_STATUS
, buf
, 1);
185 dev_dbg(dev
, "status = 0x%.2x (%d)\n", buf
[0], buf
[0]);
191 static int rv3029_eeprom_busywait(struct device
*dev
)
196 for (i
= 100; i
> 0; i
--) {
197 ret
= rv3029_get_sr(dev
, &sr
);
200 if (!(sr
& RV3029_STATUS_EEBUSY
))
202 usleep_range(1000, 10000);
205 dev_err(dev
, "EEPROM busy wait timeout.\n");
212 static int rv3029_eeprom_exit(struct device
*dev
)
214 /* Re-enable eeprom refresh */
215 return rv3029_update_bits(dev
, RV3029_ONOFF_CTRL
,
216 RV3029_ONOFF_CTRL_EERE
,
217 RV3029_ONOFF_CTRL_EERE
);
220 static int rv3029_eeprom_enter(struct device
*dev
)
225 /* Check whether we are in the allowed voltage range. */
226 ret
= rv3029_get_sr(dev
, &sr
);
229 if (sr
& (RV3029_STATUS_VLOW1
| RV3029_STATUS_VLOW2
)) {
230 /* We clear the bits and retry once just in case
231 * we had a brown out in early startup.
233 sr
&= ~RV3029_STATUS_VLOW1
;
234 sr
&= ~RV3029_STATUS_VLOW2
;
235 ret
= rv3029_set_sr(dev
, sr
);
238 usleep_range(1000, 10000);
239 ret
= rv3029_get_sr(dev
, &sr
);
242 if (sr
& (RV3029_STATUS_VLOW1
| RV3029_STATUS_VLOW2
)) {
244 "Supply voltage is too low to safely access the EEPROM.\n");
249 /* Disable eeprom refresh. */
250 ret
= rv3029_update_bits(dev
, RV3029_ONOFF_CTRL
, RV3029_ONOFF_CTRL_EERE
,
255 /* Wait for any previous eeprom accesses to finish. */
256 ret
= rv3029_eeprom_busywait(dev
);
258 rv3029_eeprom_exit(dev
);
263 static int rv3029_eeprom_read(struct device
*dev
, u8 reg
,
264 u8 buf
[], size_t len
)
268 err
= rv3029_eeprom_enter(dev
);
272 ret
= rv3029_read_regs(dev
, reg
, buf
, len
);
274 err
= rv3029_eeprom_exit(dev
);
281 static int rv3029_eeprom_write(struct device
*dev
, u8 reg
,
282 u8
const buf
[], size_t len
)
288 err
= rv3029_eeprom_enter(dev
);
292 for (i
= 0; i
< len
; i
++, reg
++) {
293 ret
= rv3029_read_regs(dev
, reg
, &tmp
, 1);
297 ret
= rv3029_write_regs(dev
, reg
, &buf
[i
], 1);
301 ret
= rv3029_eeprom_busywait(dev
);
306 err
= rv3029_eeprom_exit(dev
);
313 static int rv3029_eeprom_update_bits(struct device
*dev
,
314 u8 reg
, u8 mask
, u8 set
)
319 ret
= rv3029_eeprom_read(dev
, reg
, &buf
, 1);
324 ret
= rv3029_eeprom_write(dev
, reg
, &buf
, 1);
331 static int rv3029_read_time(struct device
*dev
, struct rtc_time
*tm
)
335 u8 regs
[RV3029_WATCH_SECTION_LEN
] = { 0, };
337 ret
= rv3029_get_sr(dev
, buf
);
339 dev_err(dev
, "%s: reading SR failed\n", __func__
);
343 ret
= rv3029_read_regs(dev
, RV3029_W_SEC
, regs
,
344 RV3029_WATCH_SECTION_LEN
);
346 dev_err(dev
, "%s: reading RTC section failed\n", __func__
);
350 tm
->tm_sec
= bcd2bin(regs
[RV3029_W_SEC
-RV3029_W_SEC
]);
351 tm
->tm_min
= bcd2bin(regs
[RV3029_W_MINUTES
-RV3029_W_SEC
]);
353 /* HR field has a more complex interpretation */
355 const u8 _hr
= regs
[RV3029_W_HOURS
-RV3029_W_SEC
];
357 if (_hr
& RV3029_REG_HR_12_24
) {
359 tm
->tm_hour
= bcd2bin(_hr
& 0x1f);
360 if (_hr
& RV3029_REG_HR_PM
) /* PM flag set */
362 } else /* 24h format */
363 tm
->tm_hour
= bcd2bin(_hr
& 0x3f);
366 tm
->tm_mday
= bcd2bin(regs
[RV3029_W_DATE
-RV3029_W_SEC
]);
367 tm
->tm_mon
= bcd2bin(regs
[RV3029_W_MONTHS
-RV3029_W_SEC
]) - 1;
368 tm
->tm_year
= bcd2bin(regs
[RV3029_W_YEARS
-RV3029_W_SEC
]) + 100;
369 tm
->tm_wday
= bcd2bin(regs
[RV3029_W_DAYS
-RV3029_W_SEC
]) - 1;
374 static int rv3029_read_alarm(struct device
*dev
, struct rtc_wkalrm
*alarm
)
376 struct rtc_time
*const tm
= &alarm
->time
;
380 ret
= rv3029_get_sr(dev
, regs
);
382 dev_err(dev
, "%s: reading SR failed\n", __func__
);
386 ret
= rv3029_read_regs(dev
, RV3029_A_SC
, regs
,
387 RV3029_ALARM_SECTION_LEN
);
390 dev_err(dev
, "%s: reading alarm section failed\n", __func__
);
394 tm
->tm_sec
= bcd2bin(regs
[RV3029_A_SC
-RV3029_A_SC
] & 0x7f);
395 tm
->tm_min
= bcd2bin(regs
[RV3029_A_MN
-RV3029_A_SC
] & 0x7f);
396 tm
->tm_hour
= bcd2bin(regs
[RV3029_A_HR
-RV3029_A_SC
] & 0x3f);
397 tm
->tm_mday
= bcd2bin(regs
[RV3029_A_DT
-RV3029_A_SC
] & 0x3f);
398 tm
->tm_mon
= bcd2bin(regs
[RV3029_A_MO
-RV3029_A_SC
] & 0x1f) - 1;
399 tm
->tm_year
= bcd2bin(regs
[RV3029_A_YR
-RV3029_A_SC
] & 0x7f) + 100;
400 tm
->tm_wday
= bcd2bin(regs
[RV3029_A_DW
-RV3029_A_SC
] & 0x07) - 1;
405 static int rv3029_rtc_alarm_set_irq(struct device
*dev
, int enable
)
409 /* enable/disable AIE irq */
410 ret
= rv3029_update_bits(dev
, RV3029_IRQ_CTRL
, RV3029_IRQ_CTRL_AIE
,
411 (enable
? RV3029_IRQ_CTRL_AIE
: 0));
413 dev_err(dev
, "can't update INT reg\n");
420 static int rv3029_set_alarm(struct device
*dev
, struct rtc_wkalrm
*alarm
)
422 struct rtc_time
*const tm
= &alarm
->time
;
427 * The clock has an 8 bit wide bcd-coded register (they never learn)
428 * for the year. tm_year is an offset from 1900 and we are interested
429 * in the 2000-2099 range, so any value less than 100 is invalid.
431 if (tm
->tm_year
< 100)
434 ret
= rv3029_get_sr(dev
, regs
);
436 dev_err(dev
, "%s: reading SR failed\n", __func__
);
439 regs
[RV3029_A_SC
-RV3029_A_SC
] = bin2bcd(tm
->tm_sec
& 0x7f);
440 regs
[RV3029_A_MN
-RV3029_A_SC
] = bin2bcd(tm
->tm_min
& 0x7f);
441 regs
[RV3029_A_HR
-RV3029_A_SC
] = bin2bcd(tm
->tm_hour
& 0x3f);
442 regs
[RV3029_A_DT
-RV3029_A_SC
] = bin2bcd(tm
->tm_mday
& 0x3f);
443 regs
[RV3029_A_MO
-RV3029_A_SC
] = bin2bcd((tm
->tm_mon
& 0x1f) - 1);
444 regs
[RV3029_A_DW
-RV3029_A_SC
] = bin2bcd((tm
->tm_wday
& 7) - 1);
445 regs
[RV3029_A_YR
-RV3029_A_SC
] = bin2bcd((tm
->tm_year
& 0x7f) - 100);
447 ret
= rv3029_write_regs(dev
, RV3029_A_SC
, regs
,
448 RV3029_ALARM_SECTION_LEN
);
452 if (alarm
->enabled
) {
454 ret
= rv3029_update_bits(dev
, RV3029_IRQ_FLAGS
,
455 RV3029_IRQ_FLAGS_AF
, 0);
457 dev_err(dev
, "can't clear alarm flag\n");
461 ret
= rv3029_rtc_alarm_set_irq(dev
, 1);
465 dev_dbg(dev
, "alarm IRQ armed\n");
467 /* disable AIE irq */
468 ret
= rv3029_rtc_alarm_set_irq(dev
, 0);
472 dev_dbg(dev
, "alarm IRQ disabled\n");
478 static int rv3029_set_time(struct device
*dev
, struct rtc_time
*tm
)
484 * The clock has an 8 bit wide bcd-coded register (they never learn)
485 * for the year. tm_year is an offset from 1900 and we are interested
486 * in the 2000-2099 range, so any value less than 100 is invalid.
488 if (tm
->tm_year
< 100)
491 regs
[RV3029_W_SEC
-RV3029_W_SEC
] = bin2bcd(tm
->tm_sec
);
492 regs
[RV3029_W_MINUTES
-RV3029_W_SEC
] = bin2bcd(tm
->tm_min
);
493 regs
[RV3029_W_HOURS
-RV3029_W_SEC
] = bin2bcd(tm
->tm_hour
);
494 regs
[RV3029_W_DATE
-RV3029_W_SEC
] = bin2bcd(tm
->tm_mday
);
495 regs
[RV3029_W_MONTHS
-RV3029_W_SEC
] = bin2bcd(tm
->tm_mon
+1);
496 regs
[RV3029_W_DAYS
-RV3029_W_SEC
] = bin2bcd((tm
->tm_wday
& 7)+1);
497 regs
[RV3029_W_YEARS
-RV3029_W_SEC
] = bin2bcd(tm
->tm_year
- 100);
499 ret
= rv3029_write_regs(dev
, RV3029_W_SEC
, regs
,
500 RV3029_WATCH_SECTION_LEN
);
504 ret
= rv3029_get_sr(dev
, regs
);
506 dev_err(dev
, "%s: reading SR failed\n", __func__
);
510 ret
= rv3029_set_sr(dev
, (regs
[0] & ~RV3029_STATUS_PON
));
512 dev_err(dev
, "%s: reading SR failed\n", __func__
);
518 static const struct rv3029_trickle_tab_elem
{
519 u32 r
; /* resistance in ohms */
520 u8 conf
; /* trickle config bits */
521 } rv3029_trickle_tab
[] = {
524 .conf
= RV3029_TRICKLE_1K
| RV3029_TRICKLE_5K
|
525 RV3029_TRICKLE_20K
| RV3029_TRICKLE_80K
,
528 .conf
= RV3029_TRICKLE_1K
| RV3029_TRICKLE_5K
|
532 .conf
= RV3029_TRICKLE_1K
| RV3029_TRICKLE_5K
|
536 .conf
= RV3029_TRICKLE_1K
| RV3029_TRICKLE_5K
,
539 .conf
= RV3029_TRICKLE_1K
| RV3029_TRICKLE_20K
|
543 .conf
= RV3029_TRICKLE_1K
| RV3029_TRICKLE_20K
,
546 .conf
= RV3029_TRICKLE_1K
| RV3029_TRICKLE_80K
,
549 .conf
= RV3029_TRICKLE_1K
,
552 .conf
= RV3029_TRICKLE_5K
| RV3029_TRICKLE_20K
|
556 .conf
= RV3029_TRICKLE_5K
| RV3029_TRICKLE_20K
,
559 .conf
= RV3029_TRICKLE_5K
| RV3029_TRICKLE_80K
,
562 .conf
= RV3029_TRICKLE_5K
,
565 .conf
= RV3029_TRICKLE_20K
| RV3029_TRICKLE_80K
,
568 .conf
= RV3029_TRICKLE_20K
,
571 .conf
= RV3029_TRICKLE_80K
,
575 static void rv3029_trickle_config(struct device
*dev
)
577 struct device_node
*of_node
= dev
->of_node
;
578 const struct rv3029_trickle_tab_elem
*elem
;
586 /* Configure the trickle charger. */
587 err
= of_property_read_u32(of_node
, "trickle-resistor-ohms", &ohms
);
589 /* Disable trickle charger. */
590 trickle_set_bits
= 0;
592 /* Enable trickle charger. */
593 for (i
= 0; i
< ARRAY_SIZE(rv3029_trickle_tab
); i
++) {
594 elem
= &rv3029_trickle_tab
[i
];
598 trickle_set_bits
= elem
->conf
;
600 "Trickle charger enabled at %d ohms resistance.\n",
603 err
= rv3029_eeprom_update_bits(dev
, RV3029_CONTROL_E2P_EECTRL
,
607 dev_err(dev
, "Failed to update trickle charger config\n");
611 #ifdef CONFIG_RTC_DRV_RV3029_HWMON
613 static int rv3029_read_temp(struct device
*dev
, int *temp_mC
)
618 ret
= rv3029_read_regs(dev
, RV3029_TEMP_PAGE
, &temp
, 1);
622 *temp_mC
= ((int)temp
- 60) * 1000;
627 static ssize_t
rv3029_hwmon_show_temp(struct device
*dev
,
628 struct device_attribute
*attr
,
633 ret
= rv3029_read_temp(dev
, &temp_mC
);
637 return sprintf(buf
, "%d\n", temp_mC
);
640 static ssize_t
rv3029_hwmon_set_update_interval(struct device
*dev
,
641 struct device_attribute
*attr
,
645 unsigned long interval_ms
;
649 ret
= kstrtoul(buf
, 10, &interval_ms
);
653 if (interval_ms
!= 0) {
654 th_set_bits
|= RV3029_EECTRL_THE
;
655 if (interval_ms
>= 16000)
656 th_set_bits
|= RV3029_EECTRL_THP
;
658 ret
= rv3029_eeprom_update_bits(dev
, RV3029_CONTROL_E2P_EECTRL
,
659 RV3029_EECTRL_THE
| RV3029_EECTRL_THP
,
667 static ssize_t
rv3029_hwmon_show_update_interval(struct device
*dev
,
668 struct device_attribute
*attr
,
671 int ret
, interval_ms
;
674 ret
= rv3029_eeprom_read(dev
, RV3029_CONTROL_E2P_EECTRL
,
679 if (eectrl
& RV3029_EECTRL_THE
) {
680 if (eectrl
& RV3029_EECTRL_THP
)
688 return sprintf(buf
, "%d\n", interval_ms
);
691 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, rv3029_hwmon_show_temp
,
693 static SENSOR_DEVICE_ATTR(update_interval
, S_IWUSR
| S_IRUGO
,
694 rv3029_hwmon_show_update_interval
,
695 rv3029_hwmon_set_update_interval
, 0);
697 static struct attribute
*rv3029_hwmon_attrs
[] = {
698 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
699 &sensor_dev_attr_update_interval
.dev_attr
.attr
,
702 ATTRIBUTE_GROUPS(rv3029_hwmon
);
704 static void rv3029_hwmon_register(struct device
*dev
, const char *name
)
706 struct rv3029_data
*rv3029
= dev_get_drvdata(dev
);
707 struct device
*hwmon_dev
;
709 hwmon_dev
= devm_hwmon_device_register_with_groups(dev
, name
, rv3029
,
710 rv3029_hwmon_groups
);
711 if (IS_ERR(hwmon_dev
)) {
712 dev_warn(dev
, "unable to register hwmon device %ld\n",
717 #else /* CONFIG_RTC_DRV_RV3029_HWMON */
719 static void rv3029_hwmon_register(struct device
*dev
, const char *name
)
723 #endif /* CONFIG_RTC_DRV_RV3029_HWMON */
725 static const struct rtc_class_ops rv3029_rtc_ops
= {
726 .read_time
= rv3029_read_time
,
727 .set_time
= rv3029_set_time
,
728 .read_alarm
= rv3029_read_alarm
,
729 .set_alarm
= rv3029_set_alarm
,
732 static struct i2c_device_id rv3029_id
[] = {
737 MODULE_DEVICE_TABLE(i2c
, rv3029_id
);
739 static int rv3029_probe(struct device
*dev
, struct regmap
*regmap
, int irq
,
742 struct rv3029_data
*rv3029
;
746 rv3029
= devm_kzalloc(dev
, sizeof(*rv3029
), GFP_KERNEL
);
750 rv3029
->regmap
= regmap
;
753 dev_set_drvdata(dev
, rv3029
);
755 rc
= rv3029_get_sr(dev
, buf
);
757 dev_err(dev
, "reading status failed\n");
761 rv3029_trickle_config(dev
);
762 rv3029_hwmon_register(dev
, name
);
764 rv3029
->rtc
= devm_rtc_device_register(dev
, name
, &rv3029_rtc_ops
,
767 return PTR_ERR_OR_ZERO(rv3029
->rtc
);
770 #if IS_ENABLED(CONFIG_I2C)
772 static int rv3029_i2c_probe(struct i2c_client
*client
,
773 const struct i2c_device_id
*id
)
775 struct regmap
*regmap
;
776 static const struct regmap_config config
= {
781 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_SMBUS_I2C_BLOCK
|
782 I2C_FUNC_SMBUS_BYTE
)) {
783 dev_err(&client
->dev
, "Adapter does not support SMBUS_I2C_BLOCK or SMBUS_I2C_BYTE\n");
787 regmap
= devm_regmap_init_i2c(client
, &config
);
788 if (IS_ERR(regmap
)) {
789 dev_err(&client
->dev
, "%s: regmap allocation failed: %ld\n",
790 __func__
, PTR_ERR(regmap
));
791 return PTR_ERR(regmap
);
794 return rv3029_probe(&client
->dev
, regmap
, client
->irq
, client
->name
);
797 static struct i2c_driver rv3029_driver
= {
799 .name
= "rtc-rv3029c2",
801 .probe
= rv3029_i2c_probe
,
802 .id_table
= rv3029_id
,
805 static int rv3029_register_driver(void)
807 return i2c_add_driver(&rv3029_driver
);
810 static void rv3029_unregister_driver(void)
812 i2c_del_driver(&rv3029_driver
);
817 static int rv3029_register_driver(void)
822 static void rv3029_unregister_driver(void)
828 #if IS_ENABLED(CONFIG_SPI_MASTER)
830 static int rv3049_probe(struct spi_device
*spi
)
832 static const struct regmap_config config
= {
836 struct regmap
*regmap
;
838 regmap
= devm_regmap_init_spi(spi
, &config
);
839 if (IS_ERR(regmap
)) {
840 dev_err(&spi
->dev
, "%s: regmap allocation failed: %ld\n",
841 __func__
, PTR_ERR(regmap
));
842 return PTR_ERR(regmap
);
845 return rv3029_probe(&spi
->dev
, regmap
, spi
->irq
, "rv3049");
848 static struct spi_driver rv3049_driver
= {
852 .probe
= rv3049_probe
,
855 static int rv3049_register_driver(void)
857 return spi_register_driver(&rv3049_driver
);
860 static void rv3049_unregister_driver(void)
862 spi_unregister_driver(&rv3049_driver
);
867 static int rv3049_register_driver(void)
872 static void rv3049_unregister_driver(void)
878 static int __init
rv30x9_init(void)
882 ret
= rv3029_register_driver();
884 pr_err("Failed to register rv3029 driver: %d\n", ret
);
888 ret
= rv3049_register_driver();
890 pr_err("Failed to register rv3049 driver: %d\n", ret
);
891 rv3029_unregister_driver();
896 module_init(rv30x9_init
)
898 static void __exit
rv30x9_exit(void)
900 rv3049_unregister_driver();
901 rv3029_unregister_driver();
903 module_exit(rv30x9_exit
)
905 MODULE_AUTHOR("Gregory Hermant <gregory.hermant@calao-systems.com>");
906 MODULE_AUTHOR("Michael Buesch <m@bues.ch>");
907 MODULE_DESCRIPTION("Micro Crystal RV3029/RV3049 RTC driver");
908 MODULE_LICENSE("GPL");
909 MODULE_ALIAS("spi:rv3049");