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 "nls.h"
  16
  17 #include "hwclock.h"
  18
  19 /*
  20  * Get defines for rtc stuff.
  21  *
  22  * Getting the rtc defines is nontrivial. The obvious way is by including
  23  * <linux/mc146818rtc.h> but that again includes <asm/io.h> which again
  24  * includes ... and on sparc and alpha this gives compilation errors for
  25  * many kernel versions. So, we give the defines ourselves here. Moreover,
  26  * some Sparc person decided to be incompatible, and used a struct rtc_time
  27  * different from that used in mc146818rtc.h.
  28  */
  29
  30 /*
  31  * On Sparcs, there is a <asm/rtc.h> that defines different ioctls (that are
  32  * required on my machine). However, this include file does not exist on
  33  * other architectures.
  34  */
  35 /* One might do:
  36 #ifdef __sparc__
  37 # include <asm/rtc.h>
  38 #endif
  39  */
  40 #ifdef __sparc__
  41 /* The following is roughly equivalent */
  42 struct sparc_rtc_time
  43 {
  44         int sec;        /* Seconds              0-59 */
  45         int min;        /* Minutes              0-59 */
  46         int hour;       /* Hour                 0-23 */
  47         int dow;        /* Day of the week      1-7  */
  48         int dom;        /* Day of the month     1-31 */
  49         int month;      /* Month of year        1-12 */
  50         int year;       /* Year                 0-99 */
  51 };
  52 #define RTCGET _IOR('p', 20, struct sparc_rtc_time)
  53 #define RTCSET _IOW('p', 21, struct sparc_rtc_time)
  54 #endif
  55
  56 /*
  57  * struct rtc_time is present since 1.3.99.
  58  * Earlier (since 1.3.89), a struct tm was used.
  59  */
  60 struct linux_rtc_time {
  61         int tm_sec;
  62         int tm_min;
  63         int tm_hour;
  64         int tm_mday;
  65         int tm_mon;
  66         int tm_year;
  67         int tm_wday;
  68         int tm_yday;
  69         int tm_isdst;
  70 };
  71
  72 /* RTC_RD_TIME etc have this definition since 1.99.9 (pre2.0-9) */
  73 #ifndef RTC_RD_TIME
  74 # define RTC_RD_TIME    _IOR('p', 0x09, struct linux_rtc_time)
  75 # define RTC_SET_TIME   _IOW('p', 0x0a, struct linux_rtc_time)
  76 # define RTC_UIE_ON     _IO('p', 0x03)  /* Update int. enable on */
  77 # define RTC_UIE_OFF    _IO('p', 0x04)  /* Update int. enable off */
  78 #endif
  79
  80 /* RTC_EPOCH_READ and RTC_EPOCH_SET are present since 2.0.34 and 2.1.89 */
  81 #ifndef RTC_EPOCH_READ
  82 # define RTC_EPOCH_READ _IOR('p', 0x0d, unsigned long)  /* Read epoch */
  83 # define RTC_EPOCH_SET  _IOW('p', 0x0e, unsigned long)  /* Set epoch */
  84 #endif
  85
  86 /*
  87  * /dev/rtc is conventionally chardev 10/135
  88  * ia64 uses /dev/efirtc, chardev 10/136
  89  * devfs (obsolete) used /dev/misc/... for miscdev
  90  * new RTC framework + udev uses dynamic major and /dev/rtc0.../dev/rtcN
  91  * ... so we need an overridable default
  92  */
  93
  94 /* default or user defined dev (by hwclock --rtc=<path>) */
  95 static const char *rtc_dev_name;
  96 static int rtc_dev_fd = -1;
  97
  98 static void close_rtc(void)
  99 {
 100         if (rtc_dev_fd != -1)
 101                 close(rtc_dev_fd);
 102         rtc_dev_fd = -1;
 103 }
 104
 105 static int open_rtc(const struct hwclock_control *ctl)
 106 {
 107         static const char *fls[] = {
 108 #ifdef __ia64__
 109                 "/dev/efirtc",
 110                 "/dev/misc/efirtc",
 111 #endif
 112                 "/dev/rtc0",
 113                 "/dev/rtc",
 114                 "/dev/misc/rtc"
 115         };
 116         size_t i;
 117
 118         if (rtc_dev_fd != -1)
 119                 return rtc_dev_fd;
 120
 121         /* --rtc option has been given */
 122         if (ctl->rtc_dev_name) {
 123                 rtc_dev_name = ctl->rtc_dev_name;
 124                 rtc_dev_fd = open(rtc_dev_name, O_RDONLY);
 125         } else {
 126                 for (i = 0; i < ARRAY_SIZE(fls); i++) {
 127                         if (ctl->verbose)
 128                                 printf(_("Trying to open: %s\n"), fls[i]);
 129                         rtc_dev_fd = open(fls[i], O_RDONLY);
 130
 131                         if (rtc_dev_fd < 0
 132                             && (errno == ENOENT || errno == ENODEV))
 133                                 continue;
 134                         rtc_dev_name = fls[i];
 135                         break;
 136                 }
 137                 if (rtc_dev_fd < 0)
 138                         rtc_dev_name = *fls;    /* default for error messages */
 139         }
 140         if (rtc_dev_fd != -1)
 141                 atexit(close_rtc);
 142         return rtc_dev_fd;
 143 }
 144
 145 static int open_rtc_or_exit(const struct hwclock_control *ctl)
 146 {
 147         int rtc_fd = open_rtc(ctl);
 148
 149         if (rtc_fd < 0) {
 150                 warn(_("cannot open rtc device"));
 151                 hwclock_exit(ctl, EXIT_FAILURE);
 152         }
 153         return rtc_fd;
 154 }
 155
 156 static int do_rtc_read_ioctl(int rtc_fd, struct tm *tm)
 157 {
 158         int rc = -1;
 159         char *ioctlname;
 160 #ifdef __sparc__
 161         /* some but not all sparcs use a different ioctl and struct */
 162         struct sparc_rtc_time stm;
 163 #endif
 164
 165         ioctlname = "RTC_RD_TIME";
 166         rc = ioctl(rtc_fd, RTC_RD_TIME, tm);
 167
 168 #ifdef __sparc__
 169         if (rc == -1) {         /* sparc sbus */
 170                 ioctlname = "RTCGET";
 171                 rc = ioctl(rtc_fd, RTCGET, &stm);
 172                 if (rc == 0) {
 173                         tm->tm_sec = stm.sec;
 174                         tm->tm_min = stm.min;
 175                         tm->tm_hour = stm.hour;
 176                         tm->tm_mday = stm.dom;
 177                         tm->tm_mon = stm.month - 1;
 178                         tm->tm_year = stm.year - 1900;
 179                         tm->tm_wday = stm.dow - 1;
 180                         tm->tm_yday = -1;       /* day in the year */
 181                 }
 182         }
 183 #endif
 184
 185         if (rc == -1) {
 186                 warn(_("ioctl(%s) to %s to read the time failed"),
 187                         ioctlname, rtc_dev_name);
 188                 return -1;
 189         }
 190
 191         tm->tm_isdst = -1;      /* don't know whether it's dst */
 192         return 0;
 193 }
 194
 195 /*
 196  * Wait for the top of a clock tick by reading /dev/rtc in a busy loop
 197  * until we see it. This function is used for rtc drivers without ioctl
 198  * interrupts. This is typical on an Alpha, where the Hardware Clock
 199  * interrupts are used by the kernel for the system clock, so aren't at
 200  * the user's disposal.
 201  */
 202 static int busywait_for_rtc_clock_tick(const struct hwclock_control *ctl,
 203                                        const int rtc_fd)
 204 {
 205         struct tm start_time;
 206         /* The time when we were called (and started waiting) */
 207         struct tm nowtime;
 208         int rc;
 209         struct timeval begin, now;
 210
 211         if (ctl->verbose) {
 212                 printf("ioctl(%d, RTC_UIE_ON, 0): %s\n",
 213                        rtc_fd, strerror(errno));
 214                 printf(_("Waiting in loop for time from %s to change\n"),
 215                        rtc_dev_name);
 216         }
 217
 218         if (do_rtc_read_ioctl(rtc_fd, &start_time))
 219                 return 1;
 220
 221         /*
 222          * Wait for change.  Should be within a second, but in case
 223          * something weird happens, we have a time limit (1.5s) on this loop
 224          * to reduce the impact of this failure.
 225          */
 226         gettimeofday(&begin, NULL);
 227         do {
 228                 rc = do_rtc_read_ioctl(rtc_fd, &nowtime);
 229                 if (rc || start_time.tm_sec != nowtime.tm_sec)
 230                         break;
 231                 gettimeofday(&now, NULL);
 232                 if (time_diff(now, begin) > 1.5) {
 233                         warnx(_("Timed out waiting for time change."));
 234                         return 1;
 235                 }
 236         } while (1);
 237
 238         if (rc)
 239                 return 1;
 240         return 0;
 241 }
 242
 243 /*
 244  * Same as synchronize_to_clock_tick(), but just for /dev/rtc.
 245  */
 246 static int synchronize_to_clock_tick_rtc(const struct hwclock_control *ctl)
 247 {
 248         int rtc_fd;             /* File descriptor of /dev/rtc */
 249         int ret = 1;
 250
 251         rtc_fd = open_rtc(ctl);
 252         if (rtc_fd == -1) {
 253                 warn(_("cannot open rtc device"));
 254                 return ret;
 255         } else {
 256                 /* Turn on update interrupts (one per second) */
 257                 int rc = ioctl(rtc_fd, RTC_UIE_ON, 0);
 258
 259                 if (rc != -1) {
 260                         /*
 261                          * Just reading rtc_fd fails on broken hardware: no
 262                          * update interrupt comes and a bootscript with a
 263                          * hwclock call hangs
 264                          */
 265                         fd_set rfds;
 266                         struct timeval tv;
 267
 268                         /*
 269                          * Wait up to ten seconds for the next update
 270                          * interrupt
 271                          */
 272                         FD_ZERO(&rfds);
 273                         FD_SET(rtc_fd, &rfds);
 274                         tv.tv_sec = 10;
 275                         tv.tv_usec = 0;
 276                         rc = select(rtc_fd + 1, &rfds, NULL, NULL, &tv);
 277                         if (0 < rc)
 278                                 ret = 0;
 279                         else if (rc == 0) {
 280                                 warnx(_("select() to %s to wait for clock tick timed out"),
 281                                       rtc_dev_name);
 282                         } else
 283                                 warn(_("select() to %s to wait for clock tick failed"),
 284                                      rtc_dev_name);
 285                         /* Turn off update interrupts */
 286                         rc = ioctl(rtc_fd, RTC_UIE_OFF, 0);
 287                         if (rc == -1)
 288                                 warn(_("ioctl() to %s to turn off update interrupts failed"),
 289                                      rtc_dev_name);
 290                 } else if (errno == ENOTTY || errno == EINVAL) {
 291                         /* rtc ioctl interrupts are unimplemented */
 292                         ret = busywait_for_rtc_clock_tick(ctl, rtc_fd);
 293                 } else
 294                         warn(_("ioctl(%d, RTC_UIE_ON, 0) to %s failed"),
 295                              rtc_fd, rtc_dev_name);
 296         }
 297         return ret;
 298 }
 299
 300 static int read_hardware_clock_rtc(const struct hwclock_control *ctl,
 301                                    struct tm *tm)
 302 {
 303         int rtc_fd, rc;
 304
 305         rtc_fd = open_rtc_or_exit(ctl);
 306
 307         /* Read the RTC time/date, return answer via tm */
 308         rc = do_rtc_read_ioctl(rtc_fd, tm);
 309
 310         return rc;
 311 }
 312
 313 /*
 314  * Set the Hardware Clock to the broken down time <new_broken_time>. Use
 315  * ioctls to "rtc" device /dev/rtc.
 316  */
 317 static int set_hardware_clock_rtc(const struct hwclock_control *ctl,
 318                                   const struct tm *new_broken_time)
 319 {
 320         int rc = -1;
 321         int rtc_fd;
 322         char *ioctlname;
 323
 324         rtc_fd = open_rtc_or_exit(ctl);
 325
 326         ioctlname = "RTC_SET_TIME";
 327         rc = ioctl(rtc_fd, RTC_SET_TIME, new_broken_time);
 328
 329 #ifdef __sparc__
 330         if (rc == -1) {         /* sparc sbus */
 331                 struct sparc_rtc_time stm;
 332
 333                 stm.sec = new_broken_time->tm_sec;
 334                 stm.min = new_broken_time->tm_min;
 335                 stm.hour = new_broken_time->tm_hour;
 336                 stm.dom = new_broken_time->tm_mday;
 337                 stm.month = new_broken_time->tm_mon + 1;
 338                 stm.year = new_broken_time->tm_year + 1900;
 339                 stm.dow = new_broken_time->tm_wday + 1;
 340
 341                 ioctlname = "RTCSET";
 342                 rc = ioctl(rtc_fd, RTCSET, &stm);
 343         }
 344 #endif
 345
 346         if (rc == -1) {
 347                 warn(_("ioctl(%s) to %s to set the time failed"),
 348                         ioctlname, rtc_dev_name);
 349                 hwclock_exit(ctl, EXIT_FAILURE);
 350         }
 351
 352         if (ctl->verbose)
 353                 printf(_("ioctl(%s) was successful.\n"), ioctlname);
 354
 355         return 0;
 356 }
 357
 358 static int get_permissions_rtc(void)
 359 {
 360         return 0;
 361 }
 362
 363 static const char *get_device_path(void)
 364 {
 365         return rtc_dev_name;
 366 }
 367
 368 static struct clock_ops rtc_interface = {
 369         N_("Using the rtc interface to the clock."),
 370         get_permissions_rtc,
 371         read_hardware_clock_rtc,
 372         set_hardware_clock_rtc,
 373         synchronize_to_clock_tick_rtc,
 374         get_device_path,
 375 };
 376
 377 /* return &rtc if /dev/rtc can be opened, NULL otherwise */
 378 struct clock_ops *probe_for_rtc_clock(const struct hwclock_control *ctl)
 379 {
 380         const int rtc_fd = open_rtc(ctl);
 381
 382         if (rtc_fd < 0)
 383                 return NULL;
 384         return &rtc_interface;
 385 }
 386
 387 #ifdef __alpha__
 388 /*
 389  * Get the Hardware Clock epoch setting from the kernel.
 390  */
 391 int get_epoch_rtc(const struct hwclock_control *ctl, unsigned long *epoch_p)
 392 {
 393         int rtc_fd;
 394
 395         rtc_fd = open_rtc(ctl);
 396         if (rtc_fd < 0) {
 397                 warn(_("cannot open %s"), rtc_dev_name);
 398                 return 1;
 399         }
 400
 401         if (ioctl(rtc_fd, RTC_EPOCH_READ, epoch_p) == -1) {
 402                 warn(_("ioctl(%d, RTC_EPOCH_READ, epoch_p) to %s failed"),
 403                      rtc_fd, rtc_dev_name);
 404                 return 1;
 405         }
 406
 407         if (ctl->verbose)
 408                 printf(_("ioctl(%d, RTC_EPOCH_READ, epoch_p) to %s succeeded.\n"),
 409                        rtc_fd, rtc_dev_name);
 410
 411         return 0;
 412 }
 413
 414 /*
 415  * Set the Hardware Clock epoch in the kernel.
 416  */
 417 int set_epoch_rtc(const struct hwclock_control *ctl)
 418 {
 419         int rtc_fd;
 420         unsigned long epoch;
 421
 422         epoch = strtoul(ctl->epoch_option, NULL, 10);
 423
 424         /* There were no RTC clocks before 1900. */
 425         if (epoch < 1900 || epoch == ULONG_MAX) {
 426                 warnx(_("invalid epoch '%s'."), ctl->epoch_option);
 427                 return 1;
 428         }
 429
 430         rtc_fd = open_rtc(ctl);
 431         if (rtc_fd < 0) {
 432                 warn(_("cannot open %s"), rtc_dev_name);
 433                 return 1;
 434         }
 435
 436         if (ioctl(rtc_fd, RTC_EPOCH_SET, epoch) == -1) {
 437                 warn(_("ioctl(%d, RTC_EPOCH_SET, %lu) to %s failed"),
 438                      rtc_fd, epoch, rtc_dev_name);
 439                 return 1;
 440         }
 441
 442         if (ctl->verbose)
 443                 printf(_("ioctl(%d, RTC_EPOCH_SET, %lu) to %s succeeded.\n"),
 444                        rtc_fd, epoch, rtc_dev_name);
 445
 446         return 0;
 447 }
 448 #endif  /* __alpha__ */