Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 2 | Real Time Clock (RTC) Drivers for Linux |
| 3 | ======================================= |
| 4 | |
| 5 | When Linux developers talk about a "Real Time Clock", they usually mean |
| 6 | something that tracks wall clock time and is battery backed so that it |
| 7 | works even with system power off. Such clocks will normally not track |
| 8 | the local time zone or daylight savings time -- unless they dual boot |
| 9 | with MS-Windows -- but will instead be set to Coordinated Universal Time |
| 10 | (UTC, formerly "Greenwich Mean Time"). |
| 11 | |
| 12 | The newest non-PC hardware tends to just count seconds, like the time(2) |
| 13 | system call reports, but RTCs also very commonly represent time using |
| 14 | the Gregorian calendar and 24 hour time, as reported by gmtime(3). |
| 15 | |
| 16 | Linux has two largely-compatible userspace RTC API families you may |
| 17 | need to know about: |
| 18 | |
| 19 | * /dev/rtc ... is the RTC provided by PC compatible systems, |
| 20 | so it's not very portable to non-x86 systems. |
| 21 | |
| 22 | * /dev/rtc0, /dev/rtc1 ... are part of a framework that's |
| 23 | supported by a wide variety of RTC chips on all systems. |
| 24 | |
| 25 | Programmers need to understand that the PC/AT functionality is not |
| 26 | always available, and some systems can do much more. That is, the |
| 27 | RTCs use the same API to make requests in both RTC frameworks (using |
| 28 | different filenames of course), but the hardware may not offer the |
| 29 | same functionality. For example, not every RTC is hooked up to an |
| 30 | IRQ, so they can't all issue alarms; and where standard PC RTCs can |
| 31 | only issue an alarm up to 24 hours in the future, other hardware may |
| 32 | be able to schedule one any time in the upcoming century. |
| 33 | |
| 34 | |
| 35 | Old PC/AT-Compatible driver: /dev/rtc |
| 36 | -------------------------------------- |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | |
| 38 | All PCs (even Alpha machines) have a Real Time Clock built into them. |
| 39 | Usually they are built into the chipset of the computer, but some may |
| 40 | actually have a Motorola MC146818 (or clone) on the board. This is the |
| 41 | clock that keeps the date and time while your computer is turned off. |
| 42 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 43 | ACPI has standardized that MC146818 functionality, and extended it in |
| 44 | a few ways (enabling longer alarm periods, and wake-from-hibernate). |
| 45 | That functionality is NOT exposed in the old driver. |
| 46 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | However it can also be used to generate signals from a slow 2Hz to a |
| 48 | relatively fast 8192Hz, in increments of powers of two. These signals |
| 49 | are reported by interrupt number 8. (Oh! So *that* is what IRQ 8 is |
| 50 | for...) It can also function as a 24hr alarm, raising IRQ 8 when the |
| 51 | alarm goes off. The alarm can also be programmed to only check any |
| 52 | subset of the three programmable values, meaning that it could be set to |
| 53 | ring on the 30th second of the 30th minute of every hour, for example. |
| 54 | The clock can also be set to generate an interrupt upon every clock |
| 55 | update, thus generating a 1Hz signal. |
| 56 | |
| 57 | The interrupts are reported via /dev/rtc (major 10, minor 135, read only |
| 58 | character device) in the form of an unsigned long. The low byte contains |
| 59 | the type of interrupt (update-done, alarm-rang, or periodic) that was |
| 60 | raised, and the remaining bytes contain the number of interrupts since |
| 61 | the last read. Status information is reported through the pseudo-file |
| 62 | /proc/driver/rtc if the /proc filesystem was enabled. The driver has |
| 63 | built in locking so that only one process is allowed to have the /dev/rtc |
| 64 | interface open at a time. |
| 65 | |
| 66 | A user process can monitor these interrupts by doing a read(2) or a |
| 67 | select(2) on /dev/rtc -- either will block/stop the user process until |
| 68 | the next interrupt is received. This is useful for things like |
| 69 | reasonably high frequency data acquisition where one doesn't want to |
| 70 | burn up 100% CPU by polling gettimeofday etc. etc. |
| 71 | |
| 72 | At high frequencies, or under high loads, the user process should check |
| 73 | the number of interrupts received since the last read to determine if |
| 74 | there has been any interrupt "pileup" so to speak. Just for reference, a |
| 75 | typical 486-33 running a tight read loop on /dev/rtc will start to suffer |
| 76 | occasional interrupt pileup (i.e. > 1 IRQ event since last read) for |
| 77 | frequencies above 1024Hz. So you really should check the high bytes |
| 78 | of the value you read, especially at frequencies above that of the |
| 79 | normal timer interrupt, which is 100Hz. |
| 80 | |
| 81 | Programming and/or enabling interrupt frequencies greater than 64Hz is |
| 82 | only allowed by root. This is perhaps a bit conservative, but we don't want |
| 83 | an evil user generating lots of IRQs on a slow 386sx-16, where it might have |
Jean Delvare | 9be05b5 | 2006-06-25 05:48:23 -0700 | [diff] [blame] | 84 | a negative impact on performance. This 64Hz limit can be changed by writing |
| 85 | a different value to /proc/sys/dev/rtc/max-user-freq. Note that the |
| 86 | interrupt handler is only a few lines of code to minimize any possibility |
| 87 | of this effect. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | |
| 89 | Also, if the kernel time is synchronized with an external source, the |
| 90 | kernel will write the time back to the CMOS clock every 11 minutes. In |
| 91 | the process of doing this, the kernel briefly turns off RTC periodic |
| 92 | interrupts, so be aware of this if you are doing serious work. If you |
| 93 | don't synchronize the kernel time with an external source (via ntp or |
| 94 | whatever) then the kernel will keep its hands off the RTC, allowing you |
| 95 | exclusive access to the device for your applications. |
| 96 | |
| 97 | The alarm and/or interrupt frequency are programmed into the RTC via |
| 98 | various ioctl(2) calls as listed in ./include/linux/rtc.h |
| 99 | Rather than write 50 pages describing the ioctl() and so on, it is |
| 100 | perhaps more useful to include a small test program that demonstrates |
| 101 | how to use them, and demonstrates the features of the driver. This is |
| 102 | probably a lot more useful to people interested in writing applications |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 103 | that will be using this driver. See the code at the end of this document. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 105 | (The original /dev/rtc driver was written by Paul Gortmaker.) |
| 106 | |
| 107 | |
| 108 | New portable "RTC Class" drivers: /dev/rtcN |
| 109 | -------------------------------------------- |
| 110 | |
| 111 | Because Linux supports many non-ACPI and non-PC platforms, some of which |
| 112 | have more than one RTC style clock, it needed a more portable solution |
| 113 | than expecting a single battery-backed MC146818 clone on every system. |
| 114 | Accordingly, a new "RTC Class" framework has been defined. It offers |
| 115 | three different userspace interfaces: |
| 116 | |
| 117 | * /dev/rtcN ... much the same as the older /dev/rtc interface |
| 118 | |
| 119 | * /sys/class/rtc/rtcN ... sysfs attributes support readonly |
| 120 | access to some RTC attributes. |
| 121 | |
Kim, Milo | 92589c9 | 2012-10-04 17:13:45 -0700 | [diff] [blame] | 122 | * /proc/driver/rtc ... the system clock RTC may expose itself |
| 123 | using a procfs interface. If there is no RTC for the system clock, |
| 124 | rtc0 is used by default. More information is (currently) shown |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 125 | here than through sysfs. |
| 126 | |
| 127 | The RTC Class framework supports a wide variety of RTCs, ranging from those |
| 128 | integrated into embeddable system-on-chip (SOC) processors to discrete chips |
| 129 | using I2C, SPI, or some other bus to communicate with the host CPU. There's |
| 130 | even support for PC-style RTCs ... including the features exposed on newer PCs |
| 131 | through ACPI. |
| 132 | |
| 133 | The new framework also removes the "one RTC per system" restriction. For |
| 134 | example, maybe the low-power battery-backed RTC is a discrete I2C chip, but |
| 135 | a high functionality RTC is integrated into the SOC. That system might read |
| 136 | the system clock from the discrete RTC, but use the integrated one for all |
| 137 | other tasks, because of its greater functionality. |
| 138 | |
Matthew Garrett | ea3d160 | 2009-09-22 16:46:31 -0700 | [diff] [blame] | 139 | SYSFS INTERFACE |
| 140 | --------------- |
| 141 | |
| 142 | The sysfs interface under /sys/class/rtc/rtcN provides access to various |
| 143 | rtc attributes without requiring the use of ioctls. All dates and times |
| 144 | are in the RTC's timezone, rather than in system time. |
| 145 | |
| 146 | date: RTC-provided date |
Matthew Garrett | d8c1acb | 2009-09-22 16:46:32 -0700 | [diff] [blame] | 147 | hctosys: 1 if the RTC provided the system time at boot via the |
| 148 | CONFIG_RTC_HCTOSYS kernel option, 0 otherwise |
Matthew Garrett | ea3d160 | 2009-09-22 16:46:31 -0700 | [diff] [blame] | 149 | max_user_freq: The maximum interrupt rate an unprivileged user may request |
| 150 | from this RTC. |
| 151 | name: The name of the RTC corresponding to this sysfs directory |
| 152 | since_epoch: The number of seconds since the epoch according to the RTC |
| 153 | time: RTC-provided time |
| 154 | wakealarm: The time at which the clock will generate a system wakeup |
| 155 | event. This is a one shot wakeup event, so must be reset |
| 156 | after wake if a daily wakeup is required. Format is either |
| 157 | seconds since the epoch or, if there's a leading +, seconds |
| 158 | in the future. |
| 159 | |
| 160 | IOCTL INTERFACE |
| 161 | --------------- |
| 162 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 163 | The ioctl() calls supported by /dev/rtc are also supported by the RTC class |
| 164 | framework. However, because the chips and systems are not standardized, |
| 165 | some PC/AT functionality might not be provided. And in the same way, some |
| 166 | newer features -- including those enabled by ACPI -- are exposed by the |
| 167 | RTC class framework, but can't be supported by the older driver. |
| 168 | |
| 169 | * RTC_RD_TIME, RTC_SET_TIME ... every RTC supports at least reading |
| 170 | time, returning the result as a Gregorian calendar date and 24 hour |
| 171 | wall clock time. To be most useful, this time may also be updated. |
| 172 | |
| 173 | * RTC_AIE_ON, RTC_AIE_OFF, RTC_ALM_SET, RTC_ALM_READ ... when the RTC |
| 174 | is connected to an IRQ line, it can often issue an alarm IRQ up to |
David Brownell | f8245c2 | 2007-05-08 00:34:07 -0700 | [diff] [blame] | 175 | 24 hours in the future. (Use RTC_WKALM_* by preference.) |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 176 | |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 177 | * RTC_WKALM_SET, RTC_WKALM_RD ... RTCs that can issue alarms beyond |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 178 | the next 24 hours use a slightly more powerful API, which supports |
| 179 | setting the longer alarm time and enabling its IRQ using a single |
| 180 | request (using the same model as EFI firmware). |
| 181 | |
John Stultz | ea04683 | 2011-02-10 15:32:59 -0800 | [diff] [blame] | 182 | * RTC_UIE_ON, RTC_UIE_OFF ... if the RTC offers IRQs, the RTC framework |
| 183 | will emulate this mechanism. |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 184 | |
John Stultz | ea04683 | 2011-02-10 15:32:59 -0800 | [diff] [blame] | 185 | * RTC_PIE_ON, RTC_PIE_OFF, RTC_IRQP_SET, RTC_IRQP_READ ... these icotls |
| 186 | are emulated via a kernel hrtimer. |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 187 | |
| 188 | In many cases, the RTC alarm can be a system wake event, used to force |
| 189 | Linux out of a low power sleep state (or hibernation) back to a fully |
| 190 | operational state. For example, a system could enter a deep power saving |
| 191 | state until it's time to execute some scheduled tasks. |
| 192 | |
John Stultz | ea04683 | 2011-02-10 15:32:59 -0800 | [diff] [blame] | 193 | Note that many of these ioctls are handled by the common rtc-dev interface. |
| 194 | Some common examples: |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 195 | |
| 196 | * RTC_RD_TIME, RTC_SET_TIME: the read_time/set_time functions will be |
| 197 | called with appropriate values. |
| 198 | |
John Stultz | ea04683 | 2011-02-10 15:32:59 -0800 | [diff] [blame] | 199 | * RTC_ALM_SET, RTC_ALM_READ, RTC_WKALM_SET, RTC_WKALM_RD: gets or sets |
| 200 | the alarm rtc_timer. May call the set_alarm driver function. |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 201 | |
John Stultz | ea04683 | 2011-02-10 15:32:59 -0800 | [diff] [blame] | 202 | * RTC_IRQP_SET, RTC_IRQP_READ: These are emulated by the generic code. |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 203 | |
John Stultz | ea04683 | 2011-02-10 15:32:59 -0800 | [diff] [blame] | 204 | * RTC_PIE_ON, RTC_PIE_OFF: These are also emulated by the generic code. |
Mike Frysinger | ad91fd8 | 2009-09-22 16:46:24 -0700 | [diff] [blame] | 205 | |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 206 | If all else fails, check out the rtc-test.c driver! |
| 207 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | |
| 209 | -------------------- 8< ---------------- 8< ----------------------------- |
| 210 | |
| 211 | /* |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 212 | * Real Time Clock Driver Test/Example Program |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 213 | * |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 214 | * Compile with: |
| 215 | * gcc -s -Wall -Wstrict-prototypes rtctest.c -o rtctest |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | * |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 217 | * Copyright (C) 1996, Paul Gortmaker. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 218 | * |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 219 | * Released under the GNU General Public License, version 2, |
| 220 | * included herein by reference. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | * |
| 222 | */ |
| 223 | |
| 224 | #include <stdio.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | #include <linux/rtc.h> |
| 226 | #include <sys/ioctl.h> |
| 227 | #include <sys/time.h> |
| 228 | #include <sys/types.h> |
| 229 | #include <fcntl.h> |
| 230 | #include <unistd.h> |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 231 | #include <stdlib.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | #include <errno.h> |
| 233 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 235 | /* |
| 236 | * This expects the new RTC class driver framework, working with |
| 237 | * clocks that will often not be clones of what the PC-AT had. |
| 238 | * Use the command line to specify another RTC if you need one. |
| 239 | */ |
| 240 | static const char default_rtc[] = "/dev/rtc0"; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 243 | int main(int argc, char **argv) |
| 244 | { |
| 245 | int i, fd, retval, irqcount = 0; |
| 246 | unsigned long tmp, data; |
| 247 | struct rtc_time rtc_tm; |
| 248 | const char *rtc = default_rtc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 250 | switch (argc) { |
| 251 | case 2: |
| 252 | rtc = argv[1]; |
| 253 | /* FALLTHROUGH */ |
| 254 | case 1: |
| 255 | break; |
| 256 | default: |
| 257 | fprintf(stderr, "usage: rtctest [rtcdev]\n"); |
| 258 | return 1; |
| 259 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 261 | fd = open(rtc, O_RDONLY); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 263 | if (fd == -1) { |
| 264 | perror(rtc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | exit(errno); |
| 266 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 267 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 268 | fprintf(stderr, "\n\t\t\tRTC Driver Test Example.\n\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 270 | /* Turn on update interrupts (one per second) */ |
| 271 | retval = ioctl(fd, RTC_UIE_ON, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | if (retval == -1) { |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 273 | if (errno == ENOTTY) { |
| 274 | fprintf(stderr, |
| 275 | "\n...Update IRQs not supported.\n"); |
| 276 | goto test_READ; |
| 277 | } |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 278 | perror("RTC_UIE_ON ioctl"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | exit(errno); |
| 280 | } |
| 281 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 282 | fprintf(stderr, "Counting 5 update (1/sec) interrupts from reading %s:", |
| 283 | rtc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 284 | fflush(stderr); |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 285 | for (i=1; i<6; i++) { |
| 286 | /* This read will block */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 287 | retval = read(fd, &data, sizeof(unsigned long)); |
| 288 | if (retval == -1) { |
Mike Frysinger | 8696e70 | 2008-02-06 01:38:57 -0800 | [diff] [blame] | 289 | perror("read"); |
| 290 | exit(errno); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | } |
| 292 | fprintf(stderr, " %d",i); |
| 293 | fflush(stderr); |
| 294 | irqcount++; |
| 295 | } |
| 296 | |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 297 | fprintf(stderr, "\nAgain, from using select(2) on /dev/rtc:"); |
| 298 | fflush(stderr); |
| 299 | for (i=1; i<6; i++) { |
| 300 | struct timeval tv = {5, 0}; /* 5 second timeout on select */ |
| 301 | fd_set readfds; |
| 302 | |
| 303 | FD_ZERO(&readfds); |
| 304 | FD_SET(fd, &readfds); |
| 305 | /* The select will wait until an RTC interrupt happens. */ |
| 306 | retval = select(fd+1, &readfds, NULL, NULL, &tv); |
| 307 | if (retval == -1) { |
| 308 | perror("select"); |
| 309 | exit(errno); |
| 310 | } |
| 311 | /* This read won't block unlike the select-less case above. */ |
| 312 | retval = read(fd, &data, sizeof(unsigned long)); |
| 313 | if (retval == -1) { |
| 314 | perror("read"); |
| 315 | exit(errno); |
| 316 | } |
| 317 | fprintf(stderr, " %d",i); |
| 318 | fflush(stderr); |
| 319 | irqcount++; |
| 320 | } |
| 321 | |
| 322 | /* Turn off update interrupts */ |
| 323 | retval = ioctl(fd, RTC_UIE_OFF, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 324 | if (retval == -1) { |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 325 | perror("RTC_UIE_OFF ioctl"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 326 | exit(errno); |
| 327 | } |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 328 | |
| 329 | test_READ: |
| 330 | /* Read the RTC time/date */ |
| 331 | retval = ioctl(fd, RTC_RD_TIME, &rtc_tm); |
| 332 | if (retval == -1) { |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 333 | perror("RTC_RD_TIME ioctl"); |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 334 | exit(errno); |
| 335 | } |
| 336 | |
| 337 | fprintf(stderr, "\n\nCurrent RTC date/time is %d-%d-%d, %02d:%02d:%02d.\n", |
| 338 | rtc_tm.tm_mday, rtc_tm.tm_mon + 1, rtc_tm.tm_year + 1900, |
| 339 | rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec); |
| 340 | |
| 341 | /* Set the alarm to 5 sec in the future, and check for rollover */ |
| 342 | rtc_tm.tm_sec += 5; |
| 343 | if (rtc_tm.tm_sec >= 60) { |
| 344 | rtc_tm.tm_sec %= 60; |
| 345 | rtc_tm.tm_min++; |
| 346 | } |
Mike Frysinger | 8696e70 | 2008-02-06 01:38:57 -0800 | [diff] [blame] | 347 | if (rtc_tm.tm_min == 60) { |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 348 | rtc_tm.tm_min = 0; |
| 349 | rtc_tm.tm_hour++; |
| 350 | } |
Mike Frysinger | 8696e70 | 2008-02-06 01:38:57 -0800 | [diff] [blame] | 351 | if (rtc_tm.tm_hour == 24) |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 352 | rtc_tm.tm_hour = 0; |
| 353 | |
| 354 | retval = ioctl(fd, RTC_ALM_SET, &rtc_tm); |
| 355 | if (retval == -1) { |
| 356 | if (errno == ENOTTY) { |
| 357 | fprintf(stderr, |
| 358 | "\n...Alarm IRQs not supported.\n"); |
| 359 | goto test_PIE; |
| 360 | } |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 361 | perror("RTC_ALM_SET ioctl"); |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 362 | exit(errno); |
| 363 | } |
| 364 | |
| 365 | /* Read the current alarm settings */ |
| 366 | retval = ioctl(fd, RTC_ALM_READ, &rtc_tm); |
| 367 | if (retval == -1) { |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 368 | perror("RTC_ALM_READ ioctl"); |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 369 | exit(errno); |
| 370 | } |
| 371 | |
| 372 | fprintf(stderr, "Alarm time now set to %02d:%02d:%02d.\n", |
| 373 | rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec); |
| 374 | |
| 375 | /* Enable alarm interrupts */ |
| 376 | retval = ioctl(fd, RTC_AIE_ON, 0); |
| 377 | if (retval == -1) { |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 378 | perror("RTC_AIE_ON ioctl"); |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 379 | exit(errno); |
| 380 | } |
| 381 | |
| 382 | fprintf(stderr, "Waiting 5 seconds for alarm..."); |
| 383 | fflush(stderr); |
| 384 | /* This blocks until the alarm ring causes an interrupt */ |
| 385 | retval = read(fd, &data, sizeof(unsigned long)); |
| 386 | if (retval == -1) { |
| 387 | perror("read"); |
| 388 | exit(errno); |
| 389 | } |
| 390 | irqcount++; |
| 391 | fprintf(stderr, " okay. Alarm rang.\n"); |
| 392 | |
| 393 | /* Disable alarm interrupts */ |
| 394 | retval = ioctl(fd, RTC_AIE_OFF, 0); |
| 395 | if (retval == -1) { |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 396 | perror("RTC_AIE_OFF ioctl"); |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 397 | exit(errno); |
| 398 | } |
| 399 | |
| 400 | test_PIE: |
| 401 | /* Read periodic IRQ rate */ |
| 402 | retval = ioctl(fd, RTC_IRQP_READ, &tmp); |
| 403 | if (retval == -1) { |
| 404 | /* not all RTCs support periodic IRQs */ |
| 405 | if (errno == ENOTTY) { |
| 406 | fprintf(stderr, "\nNo periodic IRQ support\n"); |
Hans-Christian Egtvedt | 7a39a49 | 2007-07-17 04:04:59 -0700 | [diff] [blame] | 407 | goto done; |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 408 | } |
Mike Frysinger | 2b1cd4c | 2007-02-10 01:46:30 -0800 | [diff] [blame] | 409 | perror("RTC_IRQP_READ ioctl"); |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 410 | exit(errno); |
| 411 | } |
| 412 | fprintf(stderr, "\nPeriodic IRQ rate is %ldHz.\n", tmp); |
| 413 | |
| 414 | fprintf(stderr, "Counting 20 interrupts at:"); |
| 415 | fflush(stderr); |
| 416 | |
| 417 | /* The frequencies 128Hz, 256Hz, ... 8192Hz are only allowed for root. */ |
| 418 | for (tmp=2; tmp<=64; tmp*=2) { |
| 419 | |
| 420 | retval = ioctl(fd, RTC_IRQP_SET, tmp); |
| 421 | if (retval == -1) { |
| 422 | /* not all RTCs can change their periodic IRQ rate */ |
| 423 | if (errno == ENOTTY) { |
| 424 | fprintf(stderr, |
| 425 | "\n...Periodic IRQ rate is fixed\n"); |
| 426 | goto done; |
| 427 | } |
Mike Frysinger | 8696e70 | 2008-02-06 01:38:57 -0800 | [diff] [blame] | 428 | perror("RTC_IRQP_SET ioctl"); |
| 429 | exit(errno); |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 430 | } |
| 431 | |
| 432 | fprintf(stderr, "\n%ldHz:\t", tmp); |
| 433 | fflush(stderr); |
| 434 | |
| 435 | /* Enable periodic interrupts */ |
| 436 | retval = ioctl(fd, RTC_PIE_ON, 0); |
| 437 | if (retval == -1) { |
Mike Frysinger | 8696e70 | 2008-02-06 01:38:57 -0800 | [diff] [blame] | 438 | perror("RTC_PIE_ON ioctl"); |
| 439 | exit(errno); |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 440 | } |
| 441 | |
| 442 | for (i=1; i<21; i++) { |
Mike Frysinger | 8696e70 | 2008-02-06 01:38:57 -0800 | [diff] [blame] | 443 | /* This blocks */ |
| 444 | retval = read(fd, &data, sizeof(unsigned long)); |
| 445 | if (retval == -1) { |
| 446 | perror("read"); |
| 447 | exit(errno); |
| 448 | } |
| 449 | fprintf(stderr, " %d",i); |
| 450 | fflush(stderr); |
| 451 | irqcount++; |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 452 | } |
| 453 | |
| 454 | /* Disable periodic interrupts */ |
| 455 | retval = ioctl(fd, RTC_PIE_OFF, 0); |
| 456 | if (retval == -1) { |
Mike Frysinger | 8696e70 | 2008-02-06 01:38:57 -0800 | [diff] [blame] | 457 | perror("RTC_PIE_OFF ioctl"); |
| 458 | exit(errno); |
David Brownell | 7531d8f | 2006-11-25 11:09:26 -0800 | [diff] [blame] | 459 | } |
| 460 | } |
| 461 | |
| 462 | done: |
| 463 | fprintf(stderr, "\n\n\t\t\t *** Test complete ***\n"); |
| 464 | |
| 465 | close(fd); |
| 466 | |
| 467 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | } |