2 * rtc.c - Use /dev/rtc for clock access
10 #include <sys/select.h>
15 #include "monotonic.h"
21 * Get defines for rtc stuff.
23 * Getting the rtc defines is nontrivial. The obvious way is by including
24 * <linux/mc146818rtc.h> but that again includes <asm/io.h> which again
25 * includes ... and on sparc and alpha this gives compilation errors for
26 * many kernel versions. So, we give the defines ourselves here. Moreover,
27 * some Sparc person decided to be incompatible, and used a struct rtc_time
28 * different from that used in mc146818rtc.h.
32 * On Sparcs, there is a <asm/rtc.h> that defines different ioctls (that are
33 * required on my machine). However, this include file does not exist on
34 * other architectures.
42 /* The following is roughly equivalent */
45 int sec
; /* Seconds 0-59 */
46 int min
; /* Minutes 0-59 */
47 int hour
; /* Hour 0-23 */
48 int dow
; /* Day of the week 1-7 */
49 int dom
; /* Day of the month 1-31 */
50 int month
; /* Month of year 1-12 */
51 int year
; /* Year 0-99 */
53 #define RTCGET _IOR('p', 20, struct sparc_rtc_time)
54 #define RTCSET _IOW('p', 21, struct sparc_rtc_time)
58 * struct rtc_time is present since 1.3.99.
59 * Earlier (since 1.3.89), a struct tm was used.
61 struct linux_rtc_time
{
73 /* RTC_RD_TIME etc have this definition since 1.99.9 (pre2.0-9) */
75 # define RTC_RD_TIME _IOR('p', 0x09, struct linux_rtc_time)
76 # define RTC_SET_TIME _IOW('p', 0x0a, struct linux_rtc_time)
77 # define RTC_UIE_ON _IO('p', 0x03) /* Update int. enable on */
78 # define RTC_UIE_OFF _IO('p', 0x04) /* Update int. enable off */
81 /* RTC_EPOCH_READ and RTC_EPOCH_SET are present since 2.0.34 and 2.1.89 */
82 #ifndef RTC_EPOCH_READ
83 # define RTC_EPOCH_READ _IOR('p', 0x0d, unsigned long) /* Read epoch */
84 # define RTC_EPOCH_SET _IOW('p', 0x0e, unsigned long) /* Set epoch */
88 * /dev/rtc is conventionally chardev 10/135
89 * ia64 uses /dev/efirtc, chardev 10/136
90 * devfs (obsolete) used /dev/misc/... for miscdev
91 * new RTC framework + udev uses dynamic major and /dev/rtc0.../dev/rtcN
92 * ... so we need an overridable default
95 /* default or user defined dev (by hwclock --rtc=<path>) */
96 static const char *rtc_dev_name
;
97 static int rtc_dev_fd
= -1;
99 static void close_rtc(void)
101 if (rtc_dev_fd
!= -1)
106 static int open_rtc(const struct hwclock_control
*ctl
)
108 static const char *fls
[] = {
119 if (rtc_dev_fd
!= -1)
122 /* --rtc option has been given */
123 if (ctl
->rtc_dev_name
) {
124 rtc_dev_name
= ctl
->rtc_dev_name
;
125 rtc_dev_fd
= open(rtc_dev_name
, O_RDONLY
);
127 for (i
= 0; i
< ARRAY_SIZE(fls
); i
++) {
129 printf(_("Trying to open: %s\n"), fls
[i
]);
130 rtc_dev_fd
= open(fls
[i
], O_RDONLY
);
133 && (errno
== ENOENT
|| errno
== ENODEV
))
135 rtc_dev_name
= fls
[i
];
139 rtc_dev_name
= *fls
; /* default for error messages */
141 if (rtc_dev_fd
!= -1)
146 static int open_rtc_or_exit(const struct hwclock_control
*ctl
)
148 int rtc_fd
= open_rtc(ctl
);
151 warn(_("cannot open rtc device"));
152 hwclock_exit(ctl
, EXIT_FAILURE
);
157 static int do_rtc_read_ioctl(int rtc_fd
, struct tm
*tm
)
162 /* some but not all sparcs use a different ioctl and struct */
163 struct sparc_rtc_time stm
;
166 ioctlname
= "RTC_RD_TIME";
167 rc
= ioctl(rtc_fd
, RTC_RD_TIME
, tm
);
170 if (rc
== -1) { /* sparc sbus */
171 ioctlname
= "RTCGET";
172 rc
= ioctl(rtc_fd
, RTCGET
, &stm
);
174 tm
->tm_sec
= stm
.sec
;
175 tm
->tm_min
= stm
.min
;
176 tm
->tm_hour
= stm
.hour
;
177 tm
->tm_mday
= stm
.dom
;
178 tm
->tm_mon
= stm
.month
- 1;
179 tm
->tm_year
= stm
.year
- 1900;
180 tm
->tm_wday
= stm
.dow
- 1;
181 tm
->tm_yday
= -1; /* day in the year */
187 warn(_("ioctl(%s) to %s to read the time failed"),
188 ioctlname
, rtc_dev_name
);
192 tm
->tm_isdst
= -1; /* don't know whether it's dst */
197 * Wait for the top of a clock tick by reading /dev/rtc in a busy loop
198 * until we see it. This function is used for rtc drivers without ioctl
199 * interrupts. This is typical on an Alpha, where the Hardware Clock
200 * interrupts are used by the kernel for the system clock, so aren't at
201 * the user's disposal.
203 static int busywait_for_rtc_clock_tick(const struct hwclock_control
*ctl
,
206 struct tm start_time
;
207 /* The time when we were called (and started waiting) */
210 struct timeval begin
, now
;
213 printf("ioctl(%d, RTC_UIE_ON, 0): %s\n",
214 rtc_fd
, strerror(errno
));
215 printf(_("Waiting in loop for time from %s to change\n"),
219 if (do_rtc_read_ioctl(rtc_fd
, &start_time
))
223 * Wait for change. Should be within a second, but in case
224 * something weird happens, we have a time limit (1.5s) on this loop
225 * to reduce the impact of this failure.
227 gettime_monotonic(&begin
);
229 rc
= do_rtc_read_ioctl(rtc_fd
, &nowtime
);
230 if (rc
|| start_time
.tm_sec
!= nowtime
.tm_sec
)
232 gettime_monotonic(&now
);
233 if (time_diff(now
, begin
) > 1.5) {
234 warnx(_("Timed out waiting for time change."));
245 * Same as synchronize_to_clock_tick(), but just for /dev/rtc.
247 static int synchronize_to_clock_tick_rtc(const struct hwclock_control
*ctl
)
249 int rtc_fd
; /* File descriptor of /dev/rtc */
252 rtc_fd
= open_rtc(ctl
);
254 warn(_("cannot open rtc device"));
257 /* Turn on update interrupts (one per second) */
258 int rc
= ioctl(rtc_fd
, RTC_UIE_ON
, 0);
262 * Just reading rtc_fd fails on broken hardware: no
263 * update interrupt comes and a bootscript with a
270 * Wait up to ten seconds for the next update
274 FD_SET(rtc_fd
, &rfds
);
277 rc
= select(rtc_fd
+ 1, &rfds
, NULL
, NULL
, &tv
);
281 warnx(_("select() to %s to wait for clock tick timed out"),
284 warn(_("select() to %s to wait for clock tick failed"),
286 /* Turn off update interrupts */
287 rc
= ioctl(rtc_fd
, RTC_UIE_OFF
, 0);
289 warn(_("ioctl() to %s to turn off update interrupts failed"),
291 } else if (errno
== ENOTTY
|| errno
== EINVAL
) {
292 /* rtc ioctl interrupts are unimplemented */
293 ret
= busywait_for_rtc_clock_tick(ctl
, rtc_fd
);
295 warn(_("ioctl(%d, RTC_UIE_ON, 0) to %s failed"),
296 rtc_fd
, rtc_dev_name
);
301 static int read_hardware_clock_rtc(const struct hwclock_control
*ctl
,
306 rtc_fd
= open_rtc_or_exit(ctl
);
308 /* Read the RTC time/date, return answer via tm */
309 rc
= do_rtc_read_ioctl(rtc_fd
, tm
);
315 * Set the Hardware Clock to the broken down time <new_broken_time>. Use
316 * ioctls to "rtc" device /dev/rtc.
318 static int set_hardware_clock_rtc(const struct hwclock_control
*ctl
,
319 const struct tm
*new_broken_time
)
325 rtc_fd
= open_rtc_or_exit(ctl
);
327 ioctlname
= "RTC_SET_TIME";
328 rc
= ioctl(rtc_fd
, RTC_SET_TIME
, new_broken_time
);
331 if (rc
== -1) { /* sparc sbus */
332 struct sparc_rtc_time stm
;
334 stm
.sec
= new_broken_time
->tm_sec
;
335 stm
.min
= new_broken_time
->tm_min
;
336 stm
.hour
= new_broken_time
->tm_hour
;
337 stm
.dom
= new_broken_time
->tm_mday
;
338 stm
.month
= new_broken_time
->tm_mon
+ 1;
339 stm
.year
= new_broken_time
->tm_year
+ 1900;
340 stm
.dow
= new_broken_time
->tm_wday
+ 1;
342 ioctlname
= "RTCSET";
343 rc
= ioctl(rtc_fd
, RTCSET
, &stm
);
348 warn(_("ioctl(%s) to %s to set the time failed"),
349 ioctlname
, rtc_dev_name
);
350 hwclock_exit(ctl
, EXIT_FAILURE
);
354 printf(_("ioctl(%s) was successful.\n"), ioctlname
);
359 static int get_permissions_rtc(void)
364 static const char *get_device_path(void)
369 static struct clock_ops rtc_interface
= {
370 N_("Using the rtc interface to the clock."),
372 read_hardware_clock_rtc
,
373 set_hardware_clock_rtc
,
374 synchronize_to_clock_tick_rtc
,
378 /* return &rtc if /dev/rtc can be opened, NULL otherwise */
379 struct clock_ops
*probe_for_rtc_clock(const struct hwclock_control
*ctl
)
381 const int rtc_fd
= open_rtc(ctl
);
385 return &rtc_interface
;
390 * Get the Hardware Clock epoch setting from the kernel.
392 int get_epoch_rtc(const struct hwclock_control
*ctl
, unsigned long *epoch_p
)
396 rtc_fd
= open_rtc(ctl
);
398 warn(_("cannot open %s"), rtc_dev_name
);
402 if (ioctl(rtc_fd
, RTC_EPOCH_READ
, epoch_p
) == -1) {
403 warn(_("ioctl(%d, RTC_EPOCH_READ, epoch_p) to %s failed"),
404 rtc_fd
, rtc_dev_name
);
409 printf(_("ioctl(%d, RTC_EPOCH_READ, epoch_p) to %s succeeded.\n"),
410 rtc_fd
, rtc_dev_name
);
416 * Set the Hardware Clock epoch in the kernel.
418 int set_epoch_rtc(const struct hwclock_control
*ctl
)
423 epoch
= strtoul(ctl
->epoch_option
, NULL
, 10);
425 /* There were no RTC clocks before 1900. */
426 if (epoch
< 1900 || epoch
== ULONG_MAX
) {
427 warnx(_("invalid epoch '%s'."), ctl
->epoch_option
);
431 rtc_fd
= open_rtc(ctl
);
433 warn(_("cannot open %s"), rtc_dev_name
);
437 if (ioctl(rtc_fd
, RTC_EPOCH_SET
, epoch
) == -1) {
438 warn(_("ioctl(%d, RTC_EPOCH_SET, %lu) to %s failed"),
439 rtc_fd
, epoch
, rtc_dev_name
);
444 printf(_("ioctl(%d, RTC_EPOCH_SET, %lu) to %s succeeded.\n"),
445 rtc_fd
, epoch
, rtc_dev_name
);
449 #endif /* __alpha__ */