sys-utils/hwclock-rtc.c

   1 /*
   2  * rtc.c - Use /dev/rtc for clock access
   3  */
   4 #include <asm/ioctl.h>
   5 #include <errno.h>
   6 #include <fcntl.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <sys/ioctl.h>
  10 #include <sys/select.h>
  11 #include <sys/time.h>
  12 #include <time.h>
  13 #include <unistd.h>
  14
  15 #include "monotonic.h"
  16 #include "nls.h"
  17
  18 #include "hwclock.h"
  19
  20 /*
  21  * Get defines for rtc stuff.
  22  *
  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.
  29  */
  30
  31 /*
  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.
  35  */
  36 /* One might do:
  37 #ifdef __sparc__
  38 # include <asm/rtc.h>
  39 #endif
  40  */
  41 #ifdef __sparc__
  42 /* The following is roughly equivalent */
  43 struct sparc_rtc_time
  44 {
  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 */
  52 };
  53 #define RTCGET _IOR('p', 20, struct sparc_rtc_time)
  54 #define RTCSET _IOW('p', 21, struct sparc_rtc_time)
  55 #endif
  56
  57 /*
  58  * struct rtc_time is present since 1.3.99.
  59  * Earlier (since 1.3.89), a struct tm was used.
  60  */
  61 struct linux_rtc_time {
  62         int tm_sec;
  63         int tm_min;
  64         int tm_hour;
  65         int tm_mday;
  66         int tm_mon;
  67         int tm_year;
  68         int tm_wday;
  69         int tm_yday;
  70         int tm_isdst;
  71 };
  72
  73 /* RTC_RD_TIME etc have this definition since 1.99.9 (pre2.0-9) */
  74 #ifndef RTC_RD_TIME
  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 */
  79 #endif
  80
  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 */
  85 #endif
  86
  87 /*
  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
  93  */
  94
  95 /* default or user defined dev (by hwclock --rtc=<path>) */
  96 static const char *rtc_dev_name;
  97 static int rtc_dev_fd = -1;
  98
  99 static void close_rtc(void)
 100 {
 101         if (rtc_dev_fd != -1)
 102                 close(rtc_dev_fd);
 103         rtc_dev_fd = -1;
 104 }
 105
 106 static int open_rtc(const struct hwclock_control *ctl)
 107 {
 108         static const char *fls[] = {
 109 #ifdef __ia64__
 110                 "/dev/efirtc",
 111                 "/dev/misc/efirtc",
 112 #endif
 113                 "/dev/rtc0",
 114                 "/dev/rtc",
 115                 "/dev/misc/rtc"
 116         };
 117         size_t i;
 118
 119         if (rtc_dev_fd != -1)
 120                 return rtc_dev_fd;
 121
 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);
 126         } else {
 127                 for (i = 0; i < ARRAY_SIZE(fls); i++) {
 128                         if (ctl->verbose)
 129                                 printf(_("Trying to open: %s\n"), fls[i]);
 130                         rtc_dev_fd = open(fls[i], O_RDONLY);
 131
 132                         if (rtc_dev_fd < 0
 133                             && (errno == ENOENT || errno == ENODEV))
 134                                 continue;
 135                         rtc_dev_name = fls[i];
 136                         break;
 137                 }
 138                 if (rtc_dev_fd < 0)
 139                         rtc_dev_name = *fls;    /* default for error messages */
 140         }
 141         if (rtc_dev_fd != -1)
 142                 atexit(close_rtc);
 143         return rtc_dev_fd;
 144 }
 145
 146 static int open_rtc_or_exit(const struct hwclock_control *ctl)
 147 {
 148         int rtc_fd = open_rtc(ctl);
 149
 150         if (rtc_fd < 0) {
 151                 warn(_("cannot open rtc device"));
 152                 hwclock_exit(ctl, EXIT_FAILURE);
 153         }
 154         return rtc_fd;
 155 }
 156
 157 static int do_rtc_read_ioctl(int rtc_fd, struct tm *tm)
 158 {
 159         int rc = -1;
 160         char *ioctlname;
 161 #ifdef __sparc__
 162         /* some but not all sparcs use a different ioctl and struct */
 163         struct sparc_rtc_time stm;
 164 #endif
 165
 166         ioctlname = "RTC_RD_TIME";
 167         rc = ioctl(rtc_fd, RTC_RD_TIME, tm);
 168
 169 #ifdef __sparc__
 170         if (rc == -1) {         /* sparc sbus */
 171                 ioctlname = "RTCGET";
 172                 rc = ioctl(rtc_fd, RTCGET, &stm);
 173                 if (rc == 0) {
 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 */
 182                 }
 183         }
 184 #endif
 185
 186         if (rc == -1) {
 187                 warn(_("ioctl(%s) to %s to read the time failed"),
 188                         ioctlname, rtc_dev_name);
 189                 return -1;
 190         }
 191
 192         tm->tm_isdst = -1;      /* don't know whether it's dst */
 193         return 0;
 194 }
 195
 196 /*
 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.
 202  */
 203 static int busywait_for_rtc_clock_tick(const struct hwclock_control *ctl,
 204                                        const int rtc_fd)
 205 {
 206         struct tm start_time;
 207         /* The time when we were called (and started waiting) */
 208         struct tm nowtime;
 209         int rc;
 210         struct timeval begin, now;
 211
 212         if (ctl->verbose) {
 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"),
 216                        rtc_dev_name);
 217         }
 218
 219         if (do_rtc_read_ioctl(rtc_fd, &start_time))
 220                 return 1;
 221
 222         /*
 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.
 226          */
 227         gettime_monotonic(&begin);
 228         do {
 229                 rc = do_rtc_read_ioctl(rtc_fd, &nowtime);
 230                 if (rc || start_time.tm_sec != nowtime.tm_sec)
 231                         break;
 232                 gettime_monotonic(&now);
 233                 if (time_diff(now, begin) > 1.5) {
 234                         warnx(_("Timed out waiting for time change."));
 235                         return 1;
 236                 }
 237         } while (1);
 238
 239         if (rc)
 240                 return 1;
 241         return 0;
 242 }
 243
 244 /*
 245  * Same as synchronize_to_clock_tick(), but just for /dev/rtc.
 246  */
 247 static int synchronize_to_clock_tick_rtc(const struct hwclock_control *ctl)
 248 {
 249         int rtc_fd;             /* File descriptor of /dev/rtc */
 250         int ret = 1;
 251
 252         rtc_fd = open_rtc(ctl);
 253         if (rtc_fd == -1) {
 254                 warn(_("cannot open rtc device"));
 255                 return ret;
 256         } else {
 257                 /* Turn on update interrupts (one per second) */
 258                 int rc = ioctl(rtc_fd, RTC_UIE_ON, 0);
 259
 260                 if (rc != -1) {
 261                         /*
 262                          * Just reading rtc_fd fails on broken hardware: no
 263                          * update interrupt comes and a bootscript with a
 264                          * hwclock call hangs
 265                          */
 266                         fd_set rfds;
 267                         struct timeval tv;
 268
 269                         /*
 270                          * Wait up to ten seconds for the next update
 271                          * interrupt
 272                          */
 273                         FD_ZERO(&rfds);
 274                         FD_SET(rtc_fd, &rfds);
 275                         tv.tv_sec = 10;
 276                         tv.tv_usec = 0;
 277                         rc = select(rtc_fd + 1, &rfds, NULL, NULL, &tv);
 278                         if (0 < rc)
 279                                 ret = 0;
 280                         else if (rc == 0) {
 281                                 warnx(_("select() to %s to wait for clock tick timed out"),
 282                                       rtc_dev_name);
 283                         } else
 284                                 warn(_("select() to %s to wait for clock tick failed"),
 285                                      rtc_dev_name);
 286                         /* Turn off update interrupts */
 287                         rc = ioctl(rtc_fd, RTC_UIE_OFF, 0);
 288                         if (rc == -1)
 289                                 warn(_("ioctl() to %s to turn off update interrupts failed"),
 290                                      rtc_dev_name);
 291                 } else if (errno == ENOTTY || errno == EINVAL) {
 292                         /* rtc ioctl interrupts are unimplemented */
 293                         ret = busywait_for_rtc_clock_tick(ctl, rtc_fd);
 294                 } else
 295                         warn(_("ioctl(%d, RTC_UIE_ON, 0) to %s failed"),
 296                              rtc_fd, rtc_dev_name);
 297         }
 298         return ret;
 299 }
 300
 301 static int read_hardware_clock_rtc(const struct hwclock_control *ctl,
 302                                    struct tm *tm)
 303 {
 304         int rtc_fd, rc;
 305
 306         rtc_fd = open_rtc_or_exit(ctl);
 307
 308         /* Read the RTC time/date, return answer via tm */
 309         rc = do_rtc_read_ioctl(rtc_fd, tm);
 310
 311         return rc;
 312 }
 313
 314 /*
 315  * Set the Hardware Clock to the broken down time <new_broken_time>. Use
 316  * ioctls to "rtc" device /dev/rtc.
 317  */
 318 static int set_hardware_clock_rtc(const struct hwclock_control *ctl,
 319                                   const struct tm *new_broken_time)
 320 {
 321         int rc = -1;
 322         int rtc_fd;
 323         char *ioctlname;
 324
 325         rtc_fd = open_rtc_or_exit(ctl);
 326
 327         ioctlname = "RTC_SET_TIME";
 328         rc = ioctl(rtc_fd, RTC_SET_TIME, new_broken_time);
 329
 330 #ifdef __sparc__
 331         if (rc == -1) {         /* sparc sbus */
 332                 struct sparc_rtc_time stm;
 333
 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;
 341
 342                 ioctlname = "RTCSET";
 343                 rc = ioctl(rtc_fd, RTCSET, &stm);
 344         }
 345 #endif
 346
 347         if (rc == -1) {
 348                 warn(_("ioctl(%s) to %s to set the time failed"),
 349                         ioctlname, rtc_dev_name);
 350                 hwclock_exit(ctl, EXIT_FAILURE);
 351         }
 352
 353         if (ctl->verbose)
 354                 printf(_("ioctl(%s) was successful.\n"), ioctlname);
 355
 356         return 0;
 357 }
 358
 359 static int get_permissions_rtc(void)
 360 {
 361         return 0;
 362 }
 363
 364 static const char *get_device_path(void)
 365 {
 366         return rtc_dev_name;
 367 }
 368
 369 static struct clock_ops rtc_interface = {
 370         N_("Using the rtc interface to the clock."),
 371         get_permissions_rtc,
 372         read_hardware_clock_rtc,
 373         set_hardware_clock_rtc,
 374         synchronize_to_clock_tick_rtc,
 375         get_device_path,
 376 };
 377
 378 /* return &rtc if /dev/rtc can be opened, NULL otherwise */
 379 struct clock_ops *probe_for_rtc_clock(const struct hwclock_control *ctl)
 380 {
 381         const int rtc_fd = open_rtc(ctl);
 382
 383         if (rtc_fd < 0)
 384                 return NULL;
 385         return &rtc_interface;
 386 }
 387
 388 #ifdef __alpha__
 389 /*
 390  * Get the Hardware Clock epoch setting from the kernel.
 391  */
 392 int get_epoch_rtc(const struct hwclock_control *ctl, unsigned long *epoch_p)
 393 {
 394         int rtc_fd;
 395
 396         rtc_fd = open_rtc(ctl);
 397         if (rtc_fd < 0) {
 398                 warn(_("cannot open %s"), rtc_dev_name);
 399                 return 1;
 400         }
 401
 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);
 405                 return 1;
 406         }
 407
 408         if (ctl->verbose)
 409                 printf(_("ioctl(%d, RTC_EPOCH_READ, epoch_p) to %s succeeded.\n"),
 410                        rtc_fd, rtc_dev_name);
 411
 412         return 0;
 413 }
 414
 415 /*
 416  * Set the Hardware Clock epoch in the kernel.
 417  */
 418 int set_epoch_rtc(const struct hwclock_control *ctl)
 419 {
 420         int rtc_fd;
 421         unsigned long epoch;
 422
 423         epoch = strtoul(ctl->epoch_option, NULL, 10);
 424
 425         /* There were no RTC clocks before 1900. */
 426         if (epoch < 1900 || epoch == ULONG_MAX) {
 427                 warnx(_("invalid epoch '%s'."), ctl->epoch_option);
 428                 return 1;
 429         }
 430
 431         rtc_fd = open_rtc(ctl);
 432         if (rtc_fd < 0) {
 433                 warn(_("cannot open %s"), rtc_dev_name);
 434                 return 1;
 435         }
 436
 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);
 440                 return 1;
 441         }
 442
 443         if (ctl->verbose)
 444                 printf(_("ioctl(%d, RTC_EPOCH_SET, %lu) to %s succeeded.\n"),
 445                        rtc_fd, epoch, rtc_dev_name);
 446
 447         return 0;
 448 }
 449 #endif  /* __alpha__ */