2 * rtc-ds1307.c - RTC driver for some mostly-compatible I2C chips.
4 * Copyright (C) 2005 James Chapman (ds1337 core)
5 * Copyright (C) 2006 David Brownell
6 * Copyright (C) 2009 Matthias Fuchs (rx8025 support)
7 * Copyright (C) 2012 Bertrand Achard (nvram access fixes)
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.
14 #include <linux/acpi.h>
15 #include <linux/bcd.h>
16 #include <linux/i2c.h>
17 #include <linux/init.h>
18 #include <linux/module.h>
19 #include <linux/of_device.h>
20 #include <linux/rtc/ds1307.h>
21 #include <linux/rtc.h>
22 #include <linux/slab.h>
23 #include <linux/string.h>
24 #include <linux/hwmon.h>
25 #include <linux/hwmon-sysfs.h>
26 #include <linux/clk-provider.h>
27 #include <linux/regmap.h>
30 * We can't determine type by probing, but if we expect pre-Linux code
31 * to have set the chip up as a clock (turning on the oscillator and
32 * setting the date and time), Linux can ignore the non-clock features.
33 * That's a natural job for a factory or repair bench.
51 last_ds_type
/* always last */
52 /* rs5c372 too? different address... */
55 /* RTC registers don't differ much, except for the century flag */
56 #define DS1307_REG_SECS 0x00 /* 00-59 */
57 # define DS1307_BIT_CH 0x80
58 # define DS1340_BIT_nEOSC 0x80
59 # define MCP794XX_BIT_ST 0x80
60 #define DS1307_REG_MIN 0x01 /* 00-59 */
61 # define M41T0_BIT_OF 0x80
62 #define DS1307_REG_HOUR 0x02 /* 00-23, or 1-12{am,pm} */
63 # define DS1307_BIT_12HR 0x40 /* in REG_HOUR */
64 # define DS1307_BIT_PM 0x20 /* in REG_HOUR */
65 # define DS1340_BIT_CENTURY_EN 0x80 /* in REG_HOUR */
66 # define DS1340_BIT_CENTURY 0x40 /* in REG_HOUR */
67 #define DS1307_REG_WDAY 0x03 /* 01-07 */
68 # define MCP794XX_BIT_VBATEN 0x08
69 #define DS1307_REG_MDAY 0x04 /* 01-31 */
70 #define DS1307_REG_MONTH 0x05 /* 01-12 */
71 # define DS1337_BIT_CENTURY 0x80 /* in REG_MONTH */
72 #define DS1307_REG_YEAR 0x06 /* 00-99 */
75 * Other registers (control, status, alarms, trickle charge, NVRAM, etc)
76 * start at 7, and they differ a LOT. Only control and status matter for
77 * basic RTC date and time functionality; be careful using them.
79 #define DS1307_REG_CONTROL 0x07 /* or ds1338 */
80 # define DS1307_BIT_OUT 0x80
81 # define DS1338_BIT_OSF 0x20
82 # define DS1307_BIT_SQWE 0x10
83 # define DS1307_BIT_RS1 0x02
84 # define DS1307_BIT_RS0 0x01
85 #define DS1337_REG_CONTROL 0x0e
86 # define DS1337_BIT_nEOSC 0x80
87 # define DS1339_BIT_BBSQI 0x20
88 # define DS3231_BIT_BBSQW 0x40 /* same as BBSQI */
89 # define DS1337_BIT_RS2 0x10
90 # define DS1337_BIT_RS1 0x08
91 # define DS1337_BIT_INTCN 0x04
92 # define DS1337_BIT_A2IE 0x02
93 # define DS1337_BIT_A1IE 0x01
94 #define DS1340_REG_CONTROL 0x07
95 # define DS1340_BIT_OUT 0x80
96 # define DS1340_BIT_FT 0x40
97 # define DS1340_BIT_CALIB_SIGN 0x20
98 # define DS1340_M_CALIBRATION 0x1f
99 #define DS1340_REG_FLAG 0x09
100 # define DS1340_BIT_OSF 0x80
101 #define DS1337_REG_STATUS 0x0f
102 # define DS1337_BIT_OSF 0x80
103 # define DS3231_BIT_EN32KHZ 0x08
104 # define DS1337_BIT_A2I 0x02
105 # define DS1337_BIT_A1I 0x01
106 #define DS1339_REG_ALARM1_SECS 0x07
108 #define DS13XX_TRICKLE_CHARGER_MAGIC 0xa0
110 #define RX8025_REG_CTRL1 0x0e
111 # define RX8025_BIT_2412 0x20
112 #define RX8025_REG_CTRL2 0x0f
113 # define RX8025_BIT_PON 0x10
114 # define RX8025_BIT_VDET 0x40
115 # define RX8025_BIT_XST 0x20
117 #define RX8130_REG_ALARM_MIN 0x17
118 #define RX8130_REG_ALARM_HOUR 0x18
119 #define RX8130_REG_ALARM_WEEK_OR_DAY 0x19
120 #define RX8130_REG_EXTENSION 0x1c
121 #define RX8130_REG_EXTENSION_WADA BIT(3)
122 #define RX8130_REG_FLAG 0x1d
123 #define RX8130_REG_FLAG_VLF BIT(1)
124 #define RX8130_REG_FLAG_AF BIT(3)
125 #define RX8130_REG_CONTROL0 0x1e
126 #define RX8130_REG_CONTROL0_AIE BIT(3)
128 #define MCP794XX_REG_CONTROL 0x07
129 # define MCP794XX_BIT_ALM0_EN 0x10
130 # define MCP794XX_BIT_ALM1_EN 0x20
131 #define MCP794XX_REG_ALARM0_BASE 0x0a
132 #define MCP794XX_REG_ALARM0_CTRL 0x0d
133 #define MCP794XX_REG_ALARM1_BASE 0x11
134 #define MCP794XX_REG_ALARM1_CTRL 0x14
135 # define MCP794XX_BIT_ALMX_IF BIT(3)
136 # define MCP794XX_BIT_ALMX_C0 BIT(4)
137 # define MCP794XX_BIT_ALMX_C1 BIT(5)
138 # define MCP794XX_BIT_ALMX_C2 BIT(6)
139 # define MCP794XX_BIT_ALMX_POL BIT(7)
140 # define MCP794XX_MSK_ALMX_MATCH (MCP794XX_BIT_ALMX_C0 | \
141 MCP794XX_BIT_ALMX_C1 | \
142 MCP794XX_BIT_ALMX_C2)
144 #define M41TXX_REG_CONTROL 0x07
145 # define M41TXX_BIT_OUT BIT(7)
146 # define M41TXX_BIT_FT BIT(6)
147 # define M41TXX_BIT_CALIB_SIGN BIT(5)
148 # define M41TXX_M_CALIBRATION GENMASK(4, 0)
150 /* negative offset step is -2.034ppm */
151 #define M41TXX_NEG_OFFSET_STEP_PPB 2034
152 /* positive offset step is +4.068ppm */
153 #define M41TXX_POS_OFFSET_STEP_PPB 4068
154 /* Min and max values supported with 'offset' interface by M41TXX */
155 #define M41TXX_MIN_OFFSET ((-31) * M41TXX_NEG_OFFSET_STEP_PPB)
156 #define M41TXX_MAX_OFFSET ((31) * M41TXX_POS_OFFSET_STEP_PPB)
161 #define HAS_NVRAM 0 /* bit 0 == sysfs file active */
162 #define HAS_ALARM 1 /* bit 1 == irq claimed */
164 struct regmap
*regmap
;
166 struct rtc_device
*rtc
;
167 #ifdef CONFIG_COMMON_CLK
168 struct clk_hw clks
[2];
176 u8 offset
; /* register's offset */
178 u8 century_enable_bit
;
181 irq_handler_t irq_handler
;
182 const struct rtc_class_ops
*rtc_ops
;
183 u16 trickle_charger_reg
;
184 u8 (*do_trickle_setup
)(struct ds1307
*, u32
,
188 static const struct chip_desc chips
[last_ds_type
];
190 static int ds1307_get_time(struct device
*dev
, struct rtc_time
*t
)
192 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
194 const struct chip_desc
*chip
= &chips
[ds1307
->type
];
197 if (ds1307
->type
== rx_8130
) {
198 unsigned int regflag
;
199 ret
= regmap_read(ds1307
->regmap
, RX8130_REG_FLAG
, ®flag
);
201 dev_err(dev
, "%s error %d\n", "read", ret
);
205 if (regflag
& RX8130_REG_FLAG_VLF
) {
206 dev_warn_once(dev
, "oscillator failed, set time!\n");
211 /* read the RTC date and time registers all at once */
212 ret
= regmap_bulk_read(ds1307
->regmap
, chip
->offset
, regs
,
215 dev_err(dev
, "%s error %d\n", "read", ret
);
219 dev_dbg(dev
, "%s: %7ph\n", "read", regs
);
221 /* if oscillator fail bit is set, no data can be trusted */
222 if (ds1307
->type
== m41t0
&&
223 regs
[DS1307_REG_MIN
] & M41T0_BIT_OF
) {
224 dev_warn_once(dev
, "oscillator failed, set time!\n");
228 t
->tm_sec
= bcd2bin(regs
[DS1307_REG_SECS
] & 0x7f);
229 t
->tm_min
= bcd2bin(regs
[DS1307_REG_MIN
] & 0x7f);
230 tmp
= regs
[DS1307_REG_HOUR
] & 0x3f;
231 t
->tm_hour
= bcd2bin(tmp
);
232 t
->tm_wday
= bcd2bin(regs
[DS1307_REG_WDAY
] & 0x07) - 1;
233 t
->tm_mday
= bcd2bin(regs
[DS1307_REG_MDAY
] & 0x3f);
234 tmp
= regs
[DS1307_REG_MONTH
] & 0x1f;
235 t
->tm_mon
= bcd2bin(tmp
) - 1;
236 t
->tm_year
= bcd2bin(regs
[DS1307_REG_YEAR
]) + 100;
238 if (regs
[chip
->century_reg
] & chip
->century_bit
&&
239 IS_ENABLED(CONFIG_RTC_DRV_DS1307_CENTURY
))
242 dev_dbg(dev
, "%s secs=%d, mins=%d, "
243 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
244 "read", t
->tm_sec
, t
->tm_min
,
245 t
->tm_hour
, t
->tm_mday
,
246 t
->tm_mon
, t
->tm_year
, t
->tm_wday
);
251 static int ds1307_set_time(struct device
*dev
, struct rtc_time
*t
)
253 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
254 const struct chip_desc
*chip
= &chips
[ds1307
->type
];
259 dev_dbg(dev
, "%s secs=%d, mins=%d, "
260 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
261 "write", t
->tm_sec
, t
->tm_min
,
262 t
->tm_hour
, t
->tm_mday
,
263 t
->tm_mon
, t
->tm_year
, t
->tm_wday
);
265 if (t
->tm_year
< 100)
268 #ifdef CONFIG_RTC_DRV_DS1307_CENTURY
269 if (t
->tm_year
> (chip
->century_bit
? 299 : 199))
272 if (t
->tm_year
> 199)
276 regs
[DS1307_REG_SECS
] = bin2bcd(t
->tm_sec
);
277 regs
[DS1307_REG_MIN
] = bin2bcd(t
->tm_min
);
278 regs
[DS1307_REG_HOUR
] = bin2bcd(t
->tm_hour
);
279 regs
[DS1307_REG_WDAY
] = bin2bcd(t
->tm_wday
+ 1);
280 regs
[DS1307_REG_MDAY
] = bin2bcd(t
->tm_mday
);
281 regs
[DS1307_REG_MONTH
] = bin2bcd(t
->tm_mon
+ 1);
283 /* assume 20YY not 19YY */
284 tmp
= t
->tm_year
- 100;
285 regs
[DS1307_REG_YEAR
] = bin2bcd(tmp
);
287 if (chip
->century_enable_bit
)
288 regs
[chip
->century_reg
] |= chip
->century_enable_bit
;
289 if (t
->tm_year
> 199 && chip
->century_bit
)
290 regs
[chip
->century_reg
] |= chip
->century_bit
;
292 if (ds1307
->type
== mcp794xx
) {
294 * these bits were cleared when preparing the date/time
295 * values and need to be set again before writing the
296 * regsfer out to the device.
298 regs
[DS1307_REG_SECS
] |= MCP794XX_BIT_ST
;
299 regs
[DS1307_REG_WDAY
] |= MCP794XX_BIT_VBATEN
;
302 dev_dbg(dev
, "%s: %7ph\n", "write", regs
);
304 result
= regmap_bulk_write(ds1307
->regmap
, chip
->offset
, regs
,
307 dev_err(dev
, "%s error %d\n", "write", result
);
311 if (ds1307
->type
== rx_8130
) {
312 /* clear Voltage Loss Flag as data is available now */
313 result
= regmap_write(ds1307
->regmap
, RX8130_REG_FLAG
,
314 ~(u8
)RX8130_REG_FLAG_VLF
);
316 dev_err(dev
, "%s error %d\n", "write", result
);
324 static int ds1337_read_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
326 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
330 if (!test_bit(HAS_ALARM
, &ds1307
->flags
))
333 /* read all ALARM1, ALARM2, and status registers at once */
334 ret
= regmap_bulk_read(ds1307
->regmap
, DS1339_REG_ALARM1_SECS
,
337 dev_err(dev
, "%s error %d\n", "alarm read", ret
);
341 dev_dbg(dev
, "%s: %4ph, %3ph, %2ph\n", "alarm read",
342 ®s
[0], ®s
[4], ®s
[7]);
345 * report alarm time (ALARM1); assume 24 hour and day-of-month modes,
346 * and that all four fields are checked matches
348 t
->time
.tm_sec
= bcd2bin(regs
[0] & 0x7f);
349 t
->time
.tm_min
= bcd2bin(regs
[1] & 0x7f);
350 t
->time
.tm_hour
= bcd2bin(regs
[2] & 0x3f);
351 t
->time
.tm_mday
= bcd2bin(regs
[3] & 0x3f);
354 t
->enabled
= !!(regs
[7] & DS1337_BIT_A1IE
);
355 t
->pending
= !!(regs
[8] & DS1337_BIT_A1I
);
357 dev_dbg(dev
, "%s secs=%d, mins=%d, "
358 "hours=%d, mday=%d, enabled=%d, pending=%d\n",
359 "alarm read", t
->time
.tm_sec
, t
->time
.tm_min
,
360 t
->time
.tm_hour
, t
->time
.tm_mday
,
361 t
->enabled
, t
->pending
);
366 static int ds1337_set_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
368 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
369 unsigned char regs
[9];
373 if (!test_bit(HAS_ALARM
, &ds1307
->flags
))
376 dev_dbg(dev
, "%s secs=%d, mins=%d, "
377 "hours=%d, mday=%d, enabled=%d, pending=%d\n",
378 "alarm set", t
->time
.tm_sec
, t
->time
.tm_min
,
379 t
->time
.tm_hour
, t
->time
.tm_mday
,
380 t
->enabled
, t
->pending
);
382 /* read current status of both alarms and the chip */
383 ret
= regmap_bulk_read(ds1307
->regmap
, DS1339_REG_ALARM1_SECS
, regs
,
386 dev_err(dev
, "%s error %d\n", "alarm write", ret
);
392 dev_dbg(dev
, "%s: %4ph, %3ph, %02x %02x\n", "alarm set (old status)",
393 ®s
[0], ®s
[4], control
, status
);
395 /* set ALARM1, using 24 hour and day-of-month modes */
396 regs
[0] = bin2bcd(t
->time
.tm_sec
);
397 regs
[1] = bin2bcd(t
->time
.tm_min
);
398 regs
[2] = bin2bcd(t
->time
.tm_hour
);
399 regs
[3] = bin2bcd(t
->time
.tm_mday
);
401 /* set ALARM2 to non-garbage */
407 regs
[7] = control
& ~(DS1337_BIT_A1IE
| DS1337_BIT_A2IE
);
408 regs
[8] = status
& ~(DS1337_BIT_A1I
| DS1337_BIT_A2I
);
410 ret
= regmap_bulk_write(ds1307
->regmap
, DS1339_REG_ALARM1_SECS
, regs
,
413 dev_err(dev
, "can't set alarm time\n");
417 /* optionally enable ALARM1 */
419 dev_dbg(dev
, "alarm IRQ armed\n");
420 regs
[7] |= DS1337_BIT_A1IE
; /* only ALARM1 is used */
421 regmap_write(ds1307
->regmap
, DS1337_REG_CONTROL
, regs
[7]);
427 static int ds1307_alarm_irq_enable(struct device
*dev
, unsigned int enabled
)
429 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
431 if (!test_bit(HAS_ALARM
, &ds1307
->flags
))
434 return regmap_update_bits(ds1307
->regmap
, DS1337_REG_CONTROL
,
436 enabled
? DS1337_BIT_A1IE
: 0);
439 static u8
do_trickle_setup_ds1339(struct ds1307
*ds1307
, u32 ohms
, bool diode
)
441 u8 setup
= (diode
) ? DS1307_TRICKLE_CHARGER_DIODE
:
442 DS1307_TRICKLE_CHARGER_NO_DIODE
;
446 setup
|= DS1307_TRICKLE_CHARGER_250_OHM
;
449 setup
|= DS1307_TRICKLE_CHARGER_2K_OHM
;
452 setup
|= DS1307_TRICKLE_CHARGER_4K_OHM
;
455 dev_warn(ds1307
->dev
,
456 "Unsupported ohm value %u in dt\n", ohms
);
462 static irqreturn_t
rx8130_irq(int irq
, void *dev_id
)
464 struct ds1307
*ds1307
= dev_id
;
465 struct mutex
*lock
= &ds1307
->rtc
->ops_lock
;
471 /* Read control registers. */
472 ret
= regmap_bulk_read(ds1307
->regmap
, RX8130_REG_EXTENSION
, ctl
,
476 if (!(ctl
[1] & RX8130_REG_FLAG_AF
))
478 ctl
[1] &= ~RX8130_REG_FLAG_AF
;
479 ctl
[2] &= ~RX8130_REG_CONTROL0_AIE
;
481 ret
= regmap_bulk_write(ds1307
->regmap
, RX8130_REG_EXTENSION
, ctl
,
486 rtc_update_irq(ds1307
->rtc
, 1, RTC_AF
| RTC_IRQF
);
494 static int rx8130_read_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
496 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
500 if (!test_bit(HAS_ALARM
, &ds1307
->flags
))
503 /* Read alarm registers. */
504 ret
= regmap_bulk_read(ds1307
->regmap
, RX8130_REG_ALARM_MIN
, ald
,
509 /* Read control registers. */
510 ret
= regmap_bulk_read(ds1307
->regmap
, RX8130_REG_EXTENSION
, ctl
,
515 t
->enabled
= !!(ctl
[2] & RX8130_REG_CONTROL0_AIE
);
516 t
->pending
= !!(ctl
[1] & RX8130_REG_FLAG_AF
);
518 /* Report alarm 0 time assuming 24-hour and day-of-month modes. */
520 t
->time
.tm_min
= bcd2bin(ald
[0] & 0x7f);
521 t
->time
.tm_hour
= bcd2bin(ald
[1] & 0x7f);
522 t
->time
.tm_wday
= -1;
523 t
->time
.tm_mday
= bcd2bin(ald
[2] & 0x7f);
525 t
->time
.tm_year
= -1;
526 t
->time
.tm_yday
= -1;
527 t
->time
.tm_isdst
= -1;
529 dev_dbg(dev
, "%s, sec=%d min=%d hour=%d wday=%d mday=%d mon=%d enabled=%d\n",
530 __func__
, t
->time
.tm_sec
, t
->time
.tm_min
, t
->time
.tm_hour
,
531 t
->time
.tm_wday
, t
->time
.tm_mday
, t
->time
.tm_mon
, t
->enabled
);
536 static int rx8130_set_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
538 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
542 if (!test_bit(HAS_ALARM
, &ds1307
->flags
))
545 dev_dbg(dev
, "%s, sec=%d min=%d hour=%d wday=%d mday=%d mon=%d "
546 "enabled=%d pending=%d\n", __func__
,
547 t
->time
.tm_sec
, t
->time
.tm_min
, t
->time
.tm_hour
,
548 t
->time
.tm_wday
, t
->time
.tm_mday
, t
->time
.tm_mon
,
549 t
->enabled
, t
->pending
);
551 /* Read control registers. */
552 ret
= regmap_bulk_read(ds1307
->regmap
, RX8130_REG_EXTENSION
, ctl
,
557 ctl
[0] &= RX8130_REG_EXTENSION_WADA
;
558 ctl
[1] &= ~RX8130_REG_FLAG_AF
;
559 ctl
[2] &= ~RX8130_REG_CONTROL0_AIE
;
561 ret
= regmap_bulk_write(ds1307
->regmap
, RX8130_REG_EXTENSION
, ctl
,
566 /* Hardware alarm precision is 1 minute! */
567 ald
[0] = bin2bcd(t
->time
.tm_min
);
568 ald
[1] = bin2bcd(t
->time
.tm_hour
);
569 ald
[2] = bin2bcd(t
->time
.tm_mday
);
571 ret
= regmap_bulk_write(ds1307
->regmap
, RX8130_REG_ALARM_MIN
, ald
,
579 ctl
[2] |= RX8130_REG_CONTROL0_AIE
;
581 return regmap_write(ds1307
->regmap
, RX8130_REG_CONTROL0
, ctl
[2]);
584 static int rx8130_alarm_irq_enable(struct device
*dev
, unsigned int enabled
)
586 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
589 if (!test_bit(HAS_ALARM
, &ds1307
->flags
))
592 ret
= regmap_read(ds1307
->regmap
, RX8130_REG_CONTROL0
, ®
);
597 reg
|= RX8130_REG_CONTROL0_AIE
;
599 reg
&= ~RX8130_REG_CONTROL0_AIE
;
601 return regmap_write(ds1307
->regmap
, RX8130_REG_CONTROL0
, reg
);
604 static irqreturn_t
mcp794xx_irq(int irq
, void *dev_id
)
606 struct ds1307
*ds1307
= dev_id
;
607 struct mutex
*lock
= &ds1307
->rtc
->ops_lock
;
612 /* Check and clear alarm 0 interrupt flag. */
613 ret
= regmap_read(ds1307
->regmap
, MCP794XX_REG_ALARM0_CTRL
, ®
);
616 if (!(reg
& MCP794XX_BIT_ALMX_IF
))
618 reg
&= ~MCP794XX_BIT_ALMX_IF
;
619 ret
= regmap_write(ds1307
->regmap
, MCP794XX_REG_ALARM0_CTRL
, reg
);
623 /* Disable alarm 0. */
624 ret
= regmap_update_bits(ds1307
->regmap
, MCP794XX_REG_CONTROL
,
625 MCP794XX_BIT_ALM0_EN
, 0);
629 rtc_update_irq(ds1307
->rtc
, 1, RTC_AF
| RTC_IRQF
);
637 static int mcp794xx_read_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
639 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
643 if (!test_bit(HAS_ALARM
, &ds1307
->flags
))
646 /* Read control and alarm 0 registers. */
647 ret
= regmap_bulk_read(ds1307
->regmap
, MCP794XX_REG_CONTROL
, regs
,
652 t
->enabled
= !!(regs
[0] & MCP794XX_BIT_ALM0_EN
);
654 /* Report alarm 0 time assuming 24-hour and day-of-month modes. */
655 t
->time
.tm_sec
= bcd2bin(regs
[3] & 0x7f);
656 t
->time
.tm_min
= bcd2bin(regs
[4] & 0x7f);
657 t
->time
.tm_hour
= bcd2bin(regs
[5] & 0x3f);
658 t
->time
.tm_wday
= bcd2bin(regs
[6] & 0x7) - 1;
659 t
->time
.tm_mday
= bcd2bin(regs
[7] & 0x3f);
660 t
->time
.tm_mon
= bcd2bin(regs
[8] & 0x1f) - 1;
661 t
->time
.tm_year
= -1;
662 t
->time
.tm_yday
= -1;
663 t
->time
.tm_isdst
= -1;
665 dev_dbg(dev
, "%s, sec=%d min=%d hour=%d wday=%d mday=%d mon=%d "
666 "enabled=%d polarity=%d irq=%d match=%lu\n", __func__
,
667 t
->time
.tm_sec
, t
->time
.tm_min
, t
->time
.tm_hour
,
668 t
->time
.tm_wday
, t
->time
.tm_mday
, t
->time
.tm_mon
, t
->enabled
,
669 !!(regs
[6] & MCP794XX_BIT_ALMX_POL
),
670 !!(regs
[6] & MCP794XX_BIT_ALMX_IF
),
671 (regs
[6] & MCP794XX_MSK_ALMX_MATCH
) >> 4);
677 * We may have a random RTC weekday, therefore calculate alarm weekday based
678 * on current weekday we read from the RTC timekeeping regs
680 static int mcp794xx_alm_weekday(struct device
*dev
, struct rtc_time
*tm_alarm
)
682 struct rtc_time tm_now
;
683 int days_now
, days_alarm
, ret
;
685 ret
= ds1307_get_time(dev
, &tm_now
);
689 days_now
= div_s64(rtc_tm_to_time64(&tm_now
), 24 * 60 * 60);
690 days_alarm
= div_s64(rtc_tm_to_time64(tm_alarm
), 24 * 60 * 60);
692 return (tm_now
.tm_wday
+ days_alarm
- days_now
) % 7 + 1;
695 static int mcp794xx_set_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
697 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
698 unsigned char regs
[10];
701 if (!test_bit(HAS_ALARM
, &ds1307
->flags
))
704 wday
= mcp794xx_alm_weekday(dev
, &t
->time
);
708 dev_dbg(dev
, "%s, sec=%d min=%d hour=%d wday=%d mday=%d mon=%d "
709 "enabled=%d pending=%d\n", __func__
,
710 t
->time
.tm_sec
, t
->time
.tm_min
, t
->time
.tm_hour
,
711 t
->time
.tm_wday
, t
->time
.tm_mday
, t
->time
.tm_mon
,
712 t
->enabled
, t
->pending
);
714 /* Read control and alarm 0 registers. */
715 ret
= regmap_bulk_read(ds1307
->regmap
, MCP794XX_REG_CONTROL
, regs
,
720 /* Set alarm 0, using 24-hour and day-of-month modes. */
721 regs
[3] = bin2bcd(t
->time
.tm_sec
);
722 regs
[4] = bin2bcd(t
->time
.tm_min
);
723 regs
[5] = bin2bcd(t
->time
.tm_hour
);
725 regs
[7] = bin2bcd(t
->time
.tm_mday
);
726 regs
[8] = bin2bcd(t
->time
.tm_mon
+ 1);
728 /* Clear the alarm 0 interrupt flag. */
729 regs
[6] &= ~MCP794XX_BIT_ALMX_IF
;
730 /* Set alarm match: second, minute, hour, day, date, month. */
731 regs
[6] |= MCP794XX_MSK_ALMX_MATCH
;
732 /* Disable interrupt. We will not enable until completely programmed */
733 regs
[0] &= ~MCP794XX_BIT_ALM0_EN
;
735 ret
= regmap_bulk_write(ds1307
->regmap
, MCP794XX_REG_CONTROL
, regs
,
742 regs
[0] |= MCP794XX_BIT_ALM0_EN
;
743 return regmap_write(ds1307
->regmap
, MCP794XX_REG_CONTROL
, regs
[0]);
746 static int mcp794xx_alarm_irq_enable(struct device
*dev
, unsigned int enabled
)
748 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
750 if (!test_bit(HAS_ALARM
, &ds1307
->flags
))
753 return regmap_update_bits(ds1307
->regmap
, MCP794XX_REG_CONTROL
,
754 MCP794XX_BIT_ALM0_EN
,
755 enabled
? MCP794XX_BIT_ALM0_EN
: 0);
758 static int m41txx_rtc_read_offset(struct device
*dev
, long *offset
)
760 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
761 unsigned int ctrl_reg
;
764 regmap_read(ds1307
->regmap
, M41TXX_REG_CONTROL
, &ctrl_reg
);
766 val
= ctrl_reg
& M41TXX_M_CALIBRATION
;
768 /* check if positive */
769 if (ctrl_reg
& M41TXX_BIT_CALIB_SIGN
)
770 *offset
= (val
* M41TXX_POS_OFFSET_STEP_PPB
);
772 *offset
= -(val
* M41TXX_NEG_OFFSET_STEP_PPB
);
777 static int m41txx_rtc_set_offset(struct device
*dev
, long offset
)
779 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
780 unsigned int ctrl_reg
;
782 if ((offset
< M41TXX_MIN_OFFSET
) || (offset
> M41TXX_MAX_OFFSET
))
786 ctrl_reg
= DIV_ROUND_CLOSEST(offset
,
787 M41TXX_POS_OFFSET_STEP_PPB
);
788 ctrl_reg
|= M41TXX_BIT_CALIB_SIGN
;
790 ctrl_reg
= DIV_ROUND_CLOSEST(abs(offset
),
791 M41TXX_NEG_OFFSET_STEP_PPB
);
794 return regmap_update_bits(ds1307
->regmap
, M41TXX_REG_CONTROL
,
795 M41TXX_M_CALIBRATION
| M41TXX_BIT_CALIB_SIGN
,
799 static const struct rtc_class_ops rx8130_rtc_ops
= {
800 .read_time
= ds1307_get_time
,
801 .set_time
= ds1307_set_time
,
802 .read_alarm
= rx8130_read_alarm
,
803 .set_alarm
= rx8130_set_alarm
,
804 .alarm_irq_enable
= rx8130_alarm_irq_enable
,
807 static const struct rtc_class_ops mcp794xx_rtc_ops
= {
808 .read_time
= ds1307_get_time
,
809 .set_time
= ds1307_set_time
,
810 .read_alarm
= mcp794xx_read_alarm
,
811 .set_alarm
= mcp794xx_set_alarm
,
812 .alarm_irq_enable
= mcp794xx_alarm_irq_enable
,
815 static const struct rtc_class_ops m41txx_rtc_ops
= {
816 .read_time
= ds1307_get_time
,
817 .set_time
= ds1307_set_time
,
818 .read_alarm
= ds1337_read_alarm
,
819 .set_alarm
= ds1337_set_alarm
,
820 .alarm_irq_enable
= ds1307_alarm_irq_enable
,
821 .read_offset
= m41txx_rtc_read_offset
,
822 .set_offset
= m41txx_rtc_set_offset
,
825 static const struct chip_desc chips
[last_ds_type
] = {
836 .century_reg
= DS1307_REG_MONTH
,
837 .century_bit
= DS1337_BIT_CENTURY
,
845 .century_reg
= DS1307_REG_MONTH
,
846 .century_bit
= DS1337_BIT_CENTURY
,
847 .bbsqi_bit
= DS1339_BIT_BBSQI
,
848 .trickle_charger_reg
= 0x10,
849 .do_trickle_setup
= &do_trickle_setup_ds1339
,
852 .century_reg
= DS1307_REG_HOUR
,
853 .century_enable_bit
= DS1340_BIT_CENTURY_EN
,
854 .century_bit
= DS1340_BIT_CENTURY
,
855 .do_trickle_setup
= &do_trickle_setup_ds1339
,
856 .trickle_charger_reg
= 0x08,
859 .century_reg
= DS1307_REG_MONTH
,
860 .century_bit
= DS1337_BIT_CENTURY
,
864 .trickle_charger_reg
= 0x0a,
868 .century_reg
= DS1307_REG_MONTH
,
869 .century_bit
= DS1337_BIT_CENTURY
,
870 .bbsqi_bit
= DS3231_BIT_BBSQW
,
874 /* this is battery backed SRAM */
875 .nvram_offset
= 0x20,
876 .nvram_size
= 4, /* 32bit (4 word x 8 bit) */
878 .irq_handler
= rx8130_irq
,
879 .rtc_ops
= &rx8130_rtc_ops
,
882 .rtc_ops
= &m41txx_rtc_ops
,
885 .rtc_ops
= &m41txx_rtc_ops
,
888 /* this is battery backed SRAM */
891 .rtc_ops
= &m41txx_rtc_ops
,
895 /* this is battery backed SRAM */
896 .nvram_offset
= 0x20,
898 .irq_handler
= mcp794xx_irq
,
899 .rtc_ops
= &mcp794xx_rtc_ops
,
903 static const struct i2c_device_id ds1307_id
[] = {
904 { "ds1307", ds_1307
},
905 { "ds1308", ds_1308
},
906 { "ds1337", ds_1337
},
907 { "ds1338", ds_1338
},
908 { "ds1339", ds_1339
},
909 { "ds1388", ds_1388
},
910 { "ds1340", ds_1340
},
911 { "ds1341", ds_1341
},
912 { "ds3231", ds_3231
},
914 { "m41t00", m41t00
},
915 { "m41t11", m41t11
},
916 { "mcp7940x", mcp794xx
},
917 { "mcp7941x", mcp794xx
},
918 { "pt7c4338", ds_1307
},
919 { "rx8025", rx_8025
},
920 { "isl12057", ds_1337
},
921 { "rx8130", rx_8130
},
924 MODULE_DEVICE_TABLE(i2c
, ds1307_id
);
927 static const struct of_device_id ds1307_of_match
[] = {
929 .compatible
= "dallas,ds1307",
930 .data
= (void *)ds_1307
933 .compatible
= "dallas,ds1308",
934 .data
= (void *)ds_1308
937 .compatible
= "dallas,ds1337",
938 .data
= (void *)ds_1337
941 .compatible
= "dallas,ds1338",
942 .data
= (void *)ds_1338
945 .compatible
= "dallas,ds1339",
946 .data
= (void *)ds_1339
949 .compatible
= "dallas,ds1388",
950 .data
= (void *)ds_1388
953 .compatible
= "dallas,ds1340",
954 .data
= (void *)ds_1340
957 .compatible
= "dallas,ds1341",
958 .data
= (void *)ds_1341
961 .compatible
= "maxim,ds3231",
962 .data
= (void *)ds_3231
965 .compatible
= "st,m41t0",
966 .data
= (void *)m41t0
969 .compatible
= "st,m41t00",
970 .data
= (void *)m41t00
973 .compatible
= "st,m41t11",
974 .data
= (void *)m41t11
977 .compatible
= "microchip,mcp7940x",
978 .data
= (void *)mcp794xx
981 .compatible
= "microchip,mcp7941x",
982 .data
= (void *)mcp794xx
985 .compatible
= "pericom,pt7c4338",
986 .data
= (void *)ds_1307
989 .compatible
= "epson,rx8025",
990 .data
= (void *)rx_8025
993 .compatible
= "isil,isl12057",
994 .data
= (void *)ds_1337
997 .compatible
= "epson,rx8130",
998 .data
= (void *)rx_8130
1002 MODULE_DEVICE_TABLE(of
, ds1307_of_match
);
1006 static const struct acpi_device_id ds1307_acpi_ids
[] = {
1007 { .id
= "DS1307", .driver_data
= ds_1307
},
1008 { .id
= "DS1308", .driver_data
= ds_1308
},
1009 { .id
= "DS1337", .driver_data
= ds_1337
},
1010 { .id
= "DS1338", .driver_data
= ds_1338
},
1011 { .id
= "DS1339", .driver_data
= ds_1339
},
1012 { .id
= "DS1388", .driver_data
= ds_1388
},
1013 { .id
= "DS1340", .driver_data
= ds_1340
},
1014 { .id
= "DS1341", .driver_data
= ds_1341
},
1015 { .id
= "DS3231", .driver_data
= ds_3231
},
1016 { .id
= "M41T0", .driver_data
= m41t0
},
1017 { .id
= "M41T00", .driver_data
= m41t00
},
1018 { .id
= "M41T11", .driver_data
= m41t11
},
1019 { .id
= "MCP7940X", .driver_data
= mcp794xx
},
1020 { .id
= "MCP7941X", .driver_data
= mcp794xx
},
1021 { .id
= "PT7C4338", .driver_data
= ds_1307
},
1022 { .id
= "RX8025", .driver_data
= rx_8025
},
1023 { .id
= "ISL12057", .driver_data
= ds_1337
},
1024 { .id
= "RX8130", .driver_data
= rx_8130
},
1027 MODULE_DEVICE_TABLE(acpi
, ds1307_acpi_ids
);
1031 * The ds1337 and ds1339 both have two alarms, but we only use the first
1032 * one (with a "seconds" field). For ds1337 we expect nINTA is our alarm
1033 * signal; ds1339 chips have only one alarm signal.
1035 static irqreturn_t
ds1307_irq(int irq
, void *dev_id
)
1037 struct ds1307
*ds1307
= dev_id
;
1038 struct mutex
*lock
= &ds1307
->rtc
->ops_lock
;
1042 ret
= regmap_read(ds1307
->regmap
, DS1337_REG_STATUS
, &stat
);
1046 if (stat
& DS1337_BIT_A1I
) {
1047 stat
&= ~DS1337_BIT_A1I
;
1048 regmap_write(ds1307
->regmap
, DS1337_REG_STATUS
, stat
);
1050 ret
= regmap_update_bits(ds1307
->regmap
, DS1337_REG_CONTROL
,
1051 DS1337_BIT_A1IE
, 0);
1055 rtc_update_irq(ds1307
->rtc
, 1, RTC_AF
| RTC_IRQF
);
1064 /*----------------------------------------------------------------------*/
1066 static const struct rtc_class_ops ds13xx_rtc_ops
= {
1067 .read_time
= ds1307_get_time
,
1068 .set_time
= ds1307_set_time
,
1069 .read_alarm
= ds1337_read_alarm
,
1070 .set_alarm
= ds1337_set_alarm
,
1071 .alarm_irq_enable
= ds1307_alarm_irq_enable
,
1074 static ssize_t
frequency_test_store(struct device
*dev
,
1075 struct device_attribute
*attr
,
1076 const char *buf
, size_t count
)
1078 struct ds1307
*ds1307
= dev_get_drvdata(dev
->parent
);
1082 ret
= kstrtobool(buf
, &freq_test_en
);
1084 dev_err(dev
, "Failed to store RTC Frequency Test attribute\n");
1088 regmap_update_bits(ds1307
->regmap
, M41TXX_REG_CONTROL
, M41TXX_BIT_FT
,
1089 freq_test_en
? M41TXX_BIT_FT
: 0);
1094 static ssize_t
frequency_test_show(struct device
*dev
,
1095 struct device_attribute
*attr
,
1098 struct ds1307
*ds1307
= dev_get_drvdata(dev
->parent
);
1099 unsigned int ctrl_reg
;
1101 regmap_read(ds1307
->regmap
, M41TXX_REG_CONTROL
, &ctrl_reg
);
1103 return scnprintf(buf
, PAGE_SIZE
, (ctrl_reg
& M41TXX_BIT_FT
) ? "on\n" :
1107 static DEVICE_ATTR_RW(frequency_test
);
1109 static struct attribute
*rtc_freq_test_attrs
[] = {
1110 &dev_attr_frequency_test
.attr
,
1114 static const struct attribute_group rtc_freq_test_attr_group
= {
1115 .attrs
= rtc_freq_test_attrs
,
1118 static int ds1307_add_frequency_test(struct ds1307
*ds1307
)
1122 switch (ds1307
->type
) {
1126 err
= rtc_add_group(ds1307
->rtc
, &rtc_freq_test_attr_group
);
1137 /*----------------------------------------------------------------------*/
1139 static int ds1307_nvram_read(void *priv
, unsigned int offset
, void *val
,
1142 struct ds1307
*ds1307
= priv
;
1143 const struct chip_desc
*chip
= &chips
[ds1307
->type
];
1145 return regmap_bulk_read(ds1307
->regmap
, chip
->nvram_offset
+ offset
,
1149 static int ds1307_nvram_write(void *priv
, unsigned int offset
, void *val
,
1152 struct ds1307
*ds1307
= priv
;
1153 const struct chip_desc
*chip
= &chips
[ds1307
->type
];
1155 return regmap_bulk_write(ds1307
->regmap
, chip
->nvram_offset
+ offset
,
1159 /*----------------------------------------------------------------------*/
1161 static u8
ds1307_trickle_init(struct ds1307
*ds1307
,
1162 const struct chip_desc
*chip
)
1167 if (!chip
->do_trickle_setup
)
1170 if (device_property_read_u32(ds1307
->dev
, "trickle-resistor-ohms",
1174 if (device_property_read_bool(ds1307
->dev
, "trickle-diode-disable"))
1177 return chip
->do_trickle_setup(ds1307
, ohms
, diode
);
1180 /*----------------------------------------------------------------------*/
1182 #if IS_REACHABLE(CONFIG_HWMON)
1185 * Temperature sensor support for ds3231 devices.
1188 #define DS3231_REG_TEMPERATURE 0x11
1191 * A user-initiated temperature conversion is not started by this function,
1192 * so the temperature is updated once every 64 seconds.
1194 static int ds3231_hwmon_read_temp(struct device
*dev
, s32
*mC
)
1196 struct ds1307
*ds1307
= dev_get_drvdata(dev
);
1201 ret
= regmap_bulk_read(ds1307
->regmap
, DS3231_REG_TEMPERATURE
,
1202 temp_buf
, sizeof(temp_buf
));
1206 * Temperature is represented as a 10-bit code with a resolution of
1207 * 0.25 degree celsius and encoded in two's complement format.
1209 temp
= (temp_buf
[0] << 8) | temp_buf
[1];
1216 static ssize_t
ds3231_hwmon_show_temp(struct device
*dev
,
1217 struct device_attribute
*attr
, char *buf
)
1222 ret
= ds3231_hwmon_read_temp(dev
, &temp
);
1226 return sprintf(buf
, "%d\n", temp
);
1228 static SENSOR_DEVICE_ATTR(temp1_input
, 0444, ds3231_hwmon_show_temp
,
1231 static struct attribute
*ds3231_hwmon_attrs
[] = {
1232 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
1235 ATTRIBUTE_GROUPS(ds3231_hwmon
);
1237 static void ds1307_hwmon_register(struct ds1307
*ds1307
)
1241 if (ds1307
->type
!= ds_3231
)
1244 dev
= devm_hwmon_device_register_with_groups(ds1307
->dev
, ds1307
->name
,
1246 ds3231_hwmon_groups
);
1248 dev_warn(ds1307
->dev
, "unable to register hwmon device %ld\n",
1255 static void ds1307_hwmon_register(struct ds1307
*ds1307
)
1259 #endif /* CONFIG_RTC_DRV_DS1307_HWMON */
1261 /*----------------------------------------------------------------------*/
1264 * Square-wave output support for DS3231
1265 * Datasheet: https://datasheets.maximintegrated.com/en/ds/DS3231.pdf
1267 #ifdef CONFIG_COMMON_CLK
1274 #define clk_sqw_to_ds1307(clk) \
1275 container_of(clk, struct ds1307, clks[DS3231_CLK_SQW])
1276 #define clk_32khz_to_ds1307(clk) \
1277 container_of(clk, struct ds1307, clks[DS3231_CLK_32KHZ])
1279 static int ds3231_clk_sqw_rates
[] = {
1286 static int ds1337_write_control(struct ds1307
*ds1307
, u8 mask
, u8 value
)
1288 struct mutex
*lock
= &ds1307
->rtc
->ops_lock
;
1292 ret
= regmap_update_bits(ds1307
->regmap
, DS1337_REG_CONTROL
,
1299 static unsigned long ds3231_clk_sqw_recalc_rate(struct clk_hw
*hw
,
1300 unsigned long parent_rate
)
1302 struct ds1307
*ds1307
= clk_sqw_to_ds1307(hw
);
1306 ret
= regmap_read(ds1307
->regmap
, DS1337_REG_CONTROL
, &control
);
1309 if (control
& DS1337_BIT_RS1
)
1311 if (control
& DS1337_BIT_RS2
)
1314 return ds3231_clk_sqw_rates
[rate_sel
];
1317 static long ds3231_clk_sqw_round_rate(struct clk_hw
*hw
, unsigned long rate
,
1318 unsigned long *prate
)
1322 for (i
= ARRAY_SIZE(ds3231_clk_sqw_rates
) - 1; i
>= 0; i
--) {
1323 if (ds3231_clk_sqw_rates
[i
] <= rate
)
1324 return ds3231_clk_sqw_rates
[i
];
1330 static int ds3231_clk_sqw_set_rate(struct clk_hw
*hw
, unsigned long rate
,
1331 unsigned long parent_rate
)
1333 struct ds1307
*ds1307
= clk_sqw_to_ds1307(hw
);
1337 for (rate_sel
= 0; rate_sel
< ARRAY_SIZE(ds3231_clk_sqw_rates
);
1339 if (ds3231_clk_sqw_rates
[rate_sel
] == rate
)
1343 if (rate_sel
== ARRAY_SIZE(ds3231_clk_sqw_rates
))
1347 control
|= DS1337_BIT_RS1
;
1349 control
|= DS1337_BIT_RS2
;
1351 return ds1337_write_control(ds1307
, DS1337_BIT_RS1
| DS1337_BIT_RS2
,
1355 static int ds3231_clk_sqw_prepare(struct clk_hw
*hw
)
1357 struct ds1307
*ds1307
= clk_sqw_to_ds1307(hw
);
1359 return ds1337_write_control(ds1307
, DS1337_BIT_INTCN
, 0);
1362 static void ds3231_clk_sqw_unprepare(struct clk_hw
*hw
)
1364 struct ds1307
*ds1307
= clk_sqw_to_ds1307(hw
);
1366 ds1337_write_control(ds1307
, DS1337_BIT_INTCN
, DS1337_BIT_INTCN
);
1369 static int ds3231_clk_sqw_is_prepared(struct clk_hw
*hw
)
1371 struct ds1307
*ds1307
= clk_sqw_to_ds1307(hw
);
1374 ret
= regmap_read(ds1307
->regmap
, DS1337_REG_CONTROL
, &control
);
1378 return !(control
& DS1337_BIT_INTCN
);
1381 static const struct clk_ops ds3231_clk_sqw_ops
= {
1382 .prepare
= ds3231_clk_sqw_prepare
,
1383 .unprepare
= ds3231_clk_sqw_unprepare
,
1384 .is_prepared
= ds3231_clk_sqw_is_prepared
,
1385 .recalc_rate
= ds3231_clk_sqw_recalc_rate
,
1386 .round_rate
= ds3231_clk_sqw_round_rate
,
1387 .set_rate
= ds3231_clk_sqw_set_rate
,
1390 static unsigned long ds3231_clk_32khz_recalc_rate(struct clk_hw
*hw
,
1391 unsigned long parent_rate
)
1396 static int ds3231_clk_32khz_control(struct ds1307
*ds1307
, bool enable
)
1398 struct mutex
*lock
= &ds1307
->rtc
->ops_lock
;
1402 ret
= regmap_update_bits(ds1307
->regmap
, DS1337_REG_STATUS
,
1404 enable
? DS3231_BIT_EN32KHZ
: 0);
1410 static int ds3231_clk_32khz_prepare(struct clk_hw
*hw
)
1412 struct ds1307
*ds1307
= clk_32khz_to_ds1307(hw
);
1414 return ds3231_clk_32khz_control(ds1307
, true);
1417 static void ds3231_clk_32khz_unprepare(struct clk_hw
*hw
)
1419 struct ds1307
*ds1307
= clk_32khz_to_ds1307(hw
);
1421 ds3231_clk_32khz_control(ds1307
, false);
1424 static int ds3231_clk_32khz_is_prepared(struct clk_hw
*hw
)
1426 struct ds1307
*ds1307
= clk_32khz_to_ds1307(hw
);
1429 ret
= regmap_read(ds1307
->regmap
, DS1337_REG_STATUS
, &status
);
1433 return !!(status
& DS3231_BIT_EN32KHZ
);
1436 static const struct clk_ops ds3231_clk_32khz_ops
= {
1437 .prepare
= ds3231_clk_32khz_prepare
,
1438 .unprepare
= ds3231_clk_32khz_unprepare
,
1439 .is_prepared
= ds3231_clk_32khz_is_prepared
,
1440 .recalc_rate
= ds3231_clk_32khz_recalc_rate
,
1443 static struct clk_init_data ds3231_clks_init
[] = {
1444 [DS3231_CLK_SQW
] = {
1445 .name
= "ds3231_clk_sqw",
1446 .ops
= &ds3231_clk_sqw_ops
,
1448 [DS3231_CLK_32KHZ
] = {
1449 .name
= "ds3231_clk_32khz",
1450 .ops
= &ds3231_clk_32khz_ops
,
1454 static int ds3231_clks_register(struct ds1307
*ds1307
)
1456 struct device_node
*node
= ds1307
->dev
->of_node
;
1457 struct clk_onecell_data
*onecell
;
1460 onecell
= devm_kzalloc(ds1307
->dev
, sizeof(*onecell
), GFP_KERNEL
);
1464 onecell
->clk_num
= ARRAY_SIZE(ds3231_clks_init
);
1465 onecell
->clks
= devm_kcalloc(ds1307
->dev
, onecell
->clk_num
,
1466 sizeof(onecell
->clks
[0]), GFP_KERNEL
);
1470 for (i
= 0; i
< ARRAY_SIZE(ds3231_clks_init
); i
++) {
1471 struct clk_init_data init
= ds3231_clks_init
[i
];
1474 * Interrupt signal due to alarm conditions and square-wave
1475 * output share same pin, so don't initialize both.
1477 if (i
== DS3231_CLK_SQW
&& test_bit(HAS_ALARM
, &ds1307
->flags
))
1480 /* optional override of the clockname */
1481 of_property_read_string_index(node
, "clock-output-names", i
,
1483 ds1307
->clks
[i
].init
= &init
;
1485 onecell
->clks
[i
] = devm_clk_register(ds1307
->dev
,
1487 if (IS_ERR(onecell
->clks
[i
]))
1488 return PTR_ERR(onecell
->clks
[i
]);
1494 of_clk_add_provider(node
, of_clk_src_onecell_get
, onecell
);
1499 static void ds1307_clks_register(struct ds1307
*ds1307
)
1503 if (ds1307
->type
!= ds_3231
)
1506 ret
= ds3231_clks_register(ds1307
);
1508 dev_warn(ds1307
->dev
, "unable to register clock device %d\n",
1515 static void ds1307_clks_register(struct ds1307
*ds1307
)
1519 #endif /* CONFIG_COMMON_CLK */
1521 static const struct regmap_config regmap_config
= {
1526 static int ds1307_probe(struct i2c_client
*client
,
1527 const struct i2c_device_id
*id
)
1529 struct ds1307
*ds1307
;
1532 const struct chip_desc
*chip
;
1534 bool ds1307_can_wakeup_device
= false;
1535 unsigned char regs
[8];
1536 struct ds1307_platform_data
*pdata
= dev_get_platdata(&client
->dev
);
1537 u8 trickle_charger_setup
= 0;
1539 ds1307
= devm_kzalloc(&client
->dev
, sizeof(struct ds1307
), GFP_KERNEL
);
1543 dev_set_drvdata(&client
->dev
, ds1307
);
1544 ds1307
->dev
= &client
->dev
;
1545 ds1307
->name
= client
->name
;
1547 ds1307
->regmap
= devm_regmap_init_i2c(client
, ®map_config
);
1548 if (IS_ERR(ds1307
->regmap
)) {
1549 dev_err(ds1307
->dev
, "regmap allocation failed\n");
1550 return PTR_ERR(ds1307
->regmap
);
1553 i2c_set_clientdata(client
, ds1307
);
1555 if (client
->dev
.of_node
) {
1556 ds1307
->type
= (enum ds_type
)
1557 of_device_get_match_data(&client
->dev
);
1558 chip
= &chips
[ds1307
->type
];
1560 chip
= &chips
[id
->driver_data
];
1561 ds1307
->type
= id
->driver_data
;
1563 const struct acpi_device_id
*acpi_id
;
1565 acpi_id
= acpi_match_device(ACPI_PTR(ds1307_acpi_ids
),
1569 chip
= &chips
[acpi_id
->driver_data
];
1570 ds1307
->type
= acpi_id
->driver_data
;
1573 want_irq
= client
->irq
> 0 && chip
->alarm
;
1576 trickle_charger_setup
= ds1307_trickle_init(ds1307
, chip
);
1577 else if (pdata
->trickle_charger_setup
)
1578 trickle_charger_setup
= pdata
->trickle_charger_setup
;
1580 if (trickle_charger_setup
&& chip
->trickle_charger_reg
) {
1581 trickle_charger_setup
|= DS13XX_TRICKLE_CHARGER_MAGIC
;
1582 dev_dbg(ds1307
->dev
,
1583 "writing trickle charger info 0x%x to 0x%x\n",
1584 trickle_charger_setup
, chip
->trickle_charger_reg
);
1585 regmap_write(ds1307
->regmap
, chip
->trickle_charger_reg
,
1586 trickle_charger_setup
);
1591 * For devices with no IRQ directly connected to the SoC, the RTC chip
1592 * can be forced as a wakeup source by stating that explicitly in
1593 * the device's .dts file using the "wakeup-source" boolean property.
1594 * If the "wakeup-source" property is set, don't request an IRQ.
1595 * This will guarantee the 'wakealarm' sysfs entry is available on the device,
1596 * if supported by the RTC.
1598 if (chip
->alarm
&& of_property_read_bool(client
->dev
.of_node
,
1600 ds1307_can_wakeup_device
= true;
1603 switch (ds1307
->type
) {
1608 /* get registers that the "rtc" read below won't read... */
1609 err
= regmap_bulk_read(ds1307
->regmap
, DS1337_REG_CONTROL
,
1612 dev_dbg(ds1307
->dev
, "read error %d\n", err
);
1616 /* oscillator off? turn it on, so clock can tick. */
1617 if (regs
[0] & DS1337_BIT_nEOSC
)
1618 regs
[0] &= ~DS1337_BIT_nEOSC
;
1621 * Using IRQ or defined as wakeup-source?
1622 * Disable the square wave and both alarms.
1623 * For some variants, be sure alarms can trigger when we're
1624 * running on Vbackup (BBSQI/BBSQW)
1626 if (want_irq
|| ds1307_can_wakeup_device
) {
1627 regs
[0] |= DS1337_BIT_INTCN
| chip
->bbsqi_bit
;
1628 regs
[0] &= ~(DS1337_BIT_A2IE
| DS1337_BIT_A1IE
);
1631 regmap_write(ds1307
->regmap
, DS1337_REG_CONTROL
,
1634 /* oscillator fault? clear flag, and warn */
1635 if (regs
[1] & DS1337_BIT_OSF
) {
1636 regmap_write(ds1307
->regmap
, DS1337_REG_STATUS
,
1637 regs
[1] & ~DS1337_BIT_OSF
);
1638 dev_warn(ds1307
->dev
, "SET TIME!\n");
1643 err
= regmap_bulk_read(ds1307
->regmap
,
1644 RX8025_REG_CTRL1
<< 4 | 0x08, regs
, 2);
1646 dev_dbg(ds1307
->dev
, "read error %d\n", err
);
1650 /* oscillator off? turn it on, so clock can tick. */
1651 if (!(regs
[1] & RX8025_BIT_XST
)) {
1652 regs
[1] |= RX8025_BIT_XST
;
1653 regmap_write(ds1307
->regmap
,
1654 RX8025_REG_CTRL2
<< 4 | 0x08,
1656 dev_warn(ds1307
->dev
,
1657 "oscillator stop detected - SET TIME!\n");
1660 if (regs
[1] & RX8025_BIT_PON
) {
1661 regs
[1] &= ~RX8025_BIT_PON
;
1662 regmap_write(ds1307
->regmap
,
1663 RX8025_REG_CTRL2
<< 4 | 0x08,
1665 dev_warn(ds1307
->dev
, "power-on detected\n");
1668 if (regs
[1] & RX8025_BIT_VDET
) {
1669 regs
[1] &= ~RX8025_BIT_VDET
;
1670 regmap_write(ds1307
->regmap
,
1671 RX8025_REG_CTRL2
<< 4 | 0x08,
1673 dev_warn(ds1307
->dev
, "voltage drop detected\n");
1676 /* make sure we are running in 24hour mode */
1677 if (!(regs
[0] & RX8025_BIT_2412
)) {
1680 /* switch to 24 hour mode */
1681 regmap_write(ds1307
->regmap
,
1682 RX8025_REG_CTRL1
<< 4 | 0x08,
1683 regs
[0] | RX8025_BIT_2412
);
1685 err
= regmap_bulk_read(ds1307
->regmap
,
1686 RX8025_REG_CTRL1
<< 4 | 0x08,
1689 dev_dbg(ds1307
->dev
, "read error %d\n", err
);
1694 hour
= bcd2bin(regs
[DS1307_REG_HOUR
]);
1697 if (regs
[DS1307_REG_HOUR
] & DS1307_BIT_PM
)
1700 regmap_write(ds1307
->regmap
,
1701 DS1307_REG_HOUR
<< 4 | 0x08, hour
);
1709 /* read RTC registers */
1710 err
= regmap_bulk_read(ds1307
->regmap
, chip
->offset
, regs
,
1713 dev_dbg(ds1307
->dev
, "read error %d\n", err
);
1718 * minimal sanity checking; some chips (like DS1340) don't
1719 * specify the extra bits as must-be-zero, but there are
1720 * still a few values that are clearly out-of-range.
1722 tmp
= regs
[DS1307_REG_SECS
];
1723 switch (ds1307
->type
) {
1728 /* clock halted? turn it on, so clock can tick. */
1729 if (tmp
& DS1307_BIT_CH
) {
1730 regmap_write(ds1307
->regmap
, DS1307_REG_SECS
, 0);
1731 dev_warn(ds1307
->dev
, "SET TIME!\n");
1737 /* clock halted? turn it on, so clock can tick. */
1738 if (tmp
& DS1307_BIT_CH
)
1739 regmap_write(ds1307
->regmap
, DS1307_REG_SECS
, 0);
1741 /* oscillator fault? clear flag, and warn */
1742 if (regs
[DS1307_REG_CONTROL
] & DS1338_BIT_OSF
) {
1743 regmap_write(ds1307
->regmap
, DS1307_REG_CONTROL
,
1744 regs
[DS1307_REG_CONTROL
] &
1746 dev_warn(ds1307
->dev
, "SET TIME!\n");
1751 /* clock halted? turn it on, so clock can tick. */
1752 if (tmp
& DS1340_BIT_nEOSC
)
1753 regmap_write(ds1307
->regmap
, DS1307_REG_SECS
, 0);
1755 err
= regmap_read(ds1307
->regmap
, DS1340_REG_FLAG
, &tmp
);
1757 dev_dbg(ds1307
->dev
, "read error %d\n", err
);
1761 /* oscillator fault? clear flag, and warn */
1762 if (tmp
& DS1340_BIT_OSF
) {
1763 regmap_write(ds1307
->regmap
, DS1340_REG_FLAG
, 0);
1764 dev_warn(ds1307
->dev
, "SET TIME!\n");
1768 /* make sure that the backup battery is enabled */
1769 if (!(regs
[DS1307_REG_WDAY
] & MCP794XX_BIT_VBATEN
)) {
1770 regmap_write(ds1307
->regmap
, DS1307_REG_WDAY
,
1771 regs
[DS1307_REG_WDAY
] |
1772 MCP794XX_BIT_VBATEN
);
1775 /* clock halted? turn it on, so clock can tick. */
1776 if (!(tmp
& MCP794XX_BIT_ST
)) {
1777 regmap_write(ds1307
->regmap
, DS1307_REG_SECS
,
1779 dev_warn(ds1307
->dev
, "SET TIME!\n");
1788 tmp
= regs
[DS1307_REG_HOUR
];
1789 switch (ds1307
->type
) {
1795 * NOTE: ignores century bits; fix before deploying
1796 * systems that will run through year 2100.
1802 if (!(tmp
& DS1307_BIT_12HR
))
1806 * Be sure we're in 24 hour mode. Multi-master systems
1809 tmp
= bcd2bin(tmp
& 0x1f);
1812 if (regs
[DS1307_REG_HOUR
] & DS1307_BIT_PM
)
1814 regmap_write(ds1307
->regmap
, chip
->offset
+ DS1307_REG_HOUR
,
1818 if (want_irq
|| ds1307_can_wakeup_device
) {
1819 device_set_wakeup_capable(ds1307
->dev
, true);
1820 set_bit(HAS_ALARM
, &ds1307
->flags
);
1823 ds1307
->rtc
= devm_rtc_allocate_device(ds1307
->dev
);
1824 if (IS_ERR(ds1307
->rtc
))
1825 return PTR_ERR(ds1307
->rtc
);
1827 if (ds1307_can_wakeup_device
&& !want_irq
) {
1828 dev_info(ds1307
->dev
,
1829 "'wakeup-source' is set, request for an IRQ is disabled!\n");
1830 /* We cannot support UIE mode if we do not have an IRQ line */
1831 ds1307
->rtc
->uie_unsupported
= 1;
1835 err
= devm_request_threaded_irq(ds1307
->dev
, client
->irq
, NULL
,
1836 chip
->irq_handler
?: ds1307_irq
,
1837 IRQF_SHARED
| IRQF_ONESHOT
,
1838 ds1307
->name
, ds1307
);
1841 device_set_wakeup_capable(ds1307
->dev
, false);
1842 clear_bit(HAS_ALARM
, &ds1307
->flags
);
1843 dev_err(ds1307
->dev
, "unable to request IRQ!\n");
1845 dev_dbg(ds1307
->dev
, "got IRQ %d\n", client
->irq
);
1849 ds1307
->rtc
->ops
= chip
->rtc_ops
?: &ds13xx_rtc_ops
;
1850 err
= ds1307_add_frequency_test(ds1307
);
1854 err
= rtc_register_device(ds1307
->rtc
);
1858 if (chip
->nvram_size
) {
1859 struct nvmem_config nvmem_cfg
= {
1860 .name
= "ds1307_nvram",
1863 .size
= chip
->nvram_size
,
1864 .reg_read
= ds1307_nvram_read
,
1865 .reg_write
= ds1307_nvram_write
,
1869 ds1307
->rtc
->nvram_old_abi
= true;
1870 rtc_nvmem_register(ds1307
->rtc
, &nvmem_cfg
);
1873 ds1307_hwmon_register(ds1307
);
1874 ds1307_clks_register(ds1307
);
1882 static struct i2c_driver ds1307_driver
= {
1884 .name
= "rtc-ds1307",
1885 .of_match_table
= of_match_ptr(ds1307_of_match
),
1886 .acpi_match_table
= ACPI_PTR(ds1307_acpi_ids
),
1888 .probe
= ds1307_probe
,
1889 .id_table
= ds1307_id
,
1892 module_i2c_driver(ds1307_driver
);
1894 MODULE_DESCRIPTION("RTC driver for DS1307 and similar chips");
1895 MODULE_LICENSE("GPL");