Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 2 | * RTC related functions |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | */ |
Jaswinder Singh Rajput | 8383d82 | 2009-03-21 16:56:37 +0530 | [diff] [blame] | 4 | #include <linux/platform_device.h> |
| 5 | #include <linux/mc146818rtc.h> |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 6 | #include <linux/acpi.h> |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 7 | #include <linux/bcd.h> |
Paul Gortmaker | 69c60c8 | 2011-05-26 12:22:53 -0400 | [diff] [blame^] | 8 | #include <linux/export.h> |
Stas Sergeev | 1da2e3d | 2008-06-12 15:21:54 -0700 | [diff] [blame] | 9 | #include <linux/pnp.h> |
Sebastian Andrzej Siewior | 3bcbaf6 | 2011-02-22 21:07:46 +0100 | [diff] [blame] | 10 | #include <linux/of.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | |
Ingo Molnar | cdc7957 | 2008-01-30 13:32:39 +0100 | [diff] [blame] | 12 | #include <asm/vsyscall.h> |
Feng Tang | 7bd867d | 2009-09-10 10:48:56 +0800 | [diff] [blame] | 13 | #include <asm/x86_init.h> |
Jaswinder Singh Rajput | 8383d82 | 2009-03-21 16:56:37 +0530 | [diff] [blame] | 14 | #include <asm/time.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 16 | #ifdef CONFIG_X86_32 |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 17 | /* |
| 18 | * This is a special lock that is owned by the CPU and holds the index |
| 19 | * register we are working with. It is required for NMI access to the |
| 20 | * CMOS/RTC registers. See include/asm-i386/mc146818rtc.h for details. |
| 21 | */ |
Jaswinder Singh Rajput | 8383d82 | 2009-03-21 16:56:37 +0530 | [diff] [blame] | 22 | volatile unsigned long cmos_lock; |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 23 | EXPORT_SYMBOL(cmos_lock); |
Jaswinder Singh Rajput | 8383d82 | 2009-03-21 16:56:37 +0530 | [diff] [blame] | 24 | #endif /* CONFIG_X86_32 */ |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 25 | |
Andi Kleen | b62576a | 2008-02-09 16:16:58 +0100 | [diff] [blame] | 26 | /* For two digit years assume time is always after that */ |
| 27 | #define CMOS_YEARS_OFFS 2000 |
| 28 | |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 29 | DEFINE_SPINLOCK(rtc_lock); |
| 30 | EXPORT_SYMBOL(rtc_lock); |
| 31 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | /* |
| 33 | * In order to set the CMOS clock precisely, set_rtc_mmss has to be |
| 34 | * called 500 ms after the second nowtime has started, because when |
| 35 | * nowtime is written into the registers of the CMOS clock, it will |
| 36 | * jump to the next second precisely 500 ms later. Check the Motorola |
| 37 | * MC146818A or Dallas DS12887 data sheet for details. |
| 38 | * |
| 39 | * BUG: This routine does not handle hour overflow properly; it just |
| 40 | * sets the minutes. Usually you'll only notice that after reboot! |
| 41 | */ |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 42 | int mach_set_rtc_mmss(unsigned long nowtime) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | int real_seconds, real_minutes, cmos_minutes; |
| 45 | unsigned char save_control, save_freq_select; |
Matt Fleming | 47997d7 | 2011-09-21 16:08:03 +0200 | [diff] [blame] | 46 | unsigned long flags; |
Jaswinder Singh Rajput | 8383d82 | 2009-03-21 16:56:37 +0530 | [diff] [blame] | 47 | int retval = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | |
Matt Fleming | 47997d7 | 2011-09-21 16:08:03 +0200 | [diff] [blame] | 49 | spin_lock_irqsave(&rtc_lock, flags); |
| 50 | |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 51 | /* tell the clock it's being set */ |
| 52 | save_control = CMOS_READ(RTC_CONTROL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL); |
| 54 | |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 55 | /* stop and reset prescaler */ |
| 56 | save_freq_select = CMOS_READ(RTC_FREQ_SELECT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT); |
| 58 | |
| 59 | cmos_minutes = CMOS_READ(RTC_MINUTES); |
| 60 | if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) |
Adrian Bunk | 357c6e6 | 2008-10-18 20:28:42 -0700 | [diff] [blame] | 61 | cmos_minutes = bcd2bin(cmos_minutes); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | |
| 63 | /* |
| 64 | * since we're only adjusting minutes and seconds, |
| 65 | * don't interfere with hour overflow. This avoids |
| 66 | * messing with unknown time zones but requires your |
| 67 | * RTC not to be off by more than 15 minutes |
| 68 | */ |
| 69 | real_seconds = nowtime % 60; |
| 70 | real_minutes = nowtime / 60; |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 71 | /* correct for half hour time zone */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | if (((abs(real_minutes - cmos_minutes) + 15)/30) & 1) |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 73 | real_minutes += 30; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 74 | real_minutes %= 60; |
| 75 | |
| 76 | if (abs(real_minutes - cmos_minutes) < 30) { |
| 77 | if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) { |
Adrian Bunk | 357c6e6 | 2008-10-18 20:28:42 -0700 | [diff] [blame] | 78 | real_seconds = bin2bcd(real_seconds); |
| 79 | real_minutes = bin2bcd(real_minutes); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | } |
Jaswinder Singh Rajput | 8383d82 | 2009-03-21 16:56:37 +0530 | [diff] [blame] | 81 | CMOS_WRITE(real_seconds, RTC_SECONDS); |
| 82 | CMOS_WRITE(real_minutes, RTC_MINUTES); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 83 | } else { |
Stephen Hemminger | 3e5c124 | 2011-01-12 16:59:31 -0800 | [diff] [blame] | 84 | printk_once(KERN_NOTICE |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | "set_rtc_mmss: can't update from %d to %d\n", |
| 86 | cmos_minutes, real_minutes); |
| 87 | retval = -1; |
| 88 | } |
| 89 | |
| 90 | /* The following flags have to be released exactly in this order, |
| 91 | * otherwise the DS12887 (popular MC146818A clone with integrated |
| 92 | * battery and quartz) will not reset the oscillator and will not |
| 93 | * update precisely 500 ms later. You won't find this mentioned in |
| 94 | * the Dallas Semiconductor data sheets, but who believes data |
| 95 | * sheets anyway ... -- Markus Kuhn |
| 96 | */ |
| 97 | CMOS_WRITE(save_control, RTC_CONTROL); |
| 98 | CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT); |
| 99 | |
Matt Fleming | 47997d7 | 2011-09-21 16:08:03 +0200 | [diff] [blame] | 100 | spin_unlock_irqrestore(&rtc_lock, flags); |
| 101 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | return retval; |
| 103 | } |
| 104 | |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 105 | unsigned long mach_get_cmos_time(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | { |
Andi Kleen | 068c922 | 2008-02-09 16:16:59 +0100 | [diff] [blame] | 107 | unsigned int status, year, mon, day, hour, min, sec, century = 0; |
Matt Fleming | 47997d7 | 2011-09-21 16:08:03 +0200 | [diff] [blame] | 108 | unsigned long flags; |
| 109 | |
| 110 | spin_lock_irqsave(&rtc_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 112 | /* |
| 113 | * If UIP is clear, then we have >= 244 microseconds before |
| 114 | * RTC registers will be updated. Spec sheet says that this |
| 115 | * is the reliable way to read RTC - registers. If UIP is set |
| 116 | * then the register access might be invalid. |
| 117 | */ |
| 118 | while ((CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP)) |
| 119 | cpu_relax(); |
Matt Mackall | 63732c2 | 2006-03-28 01:55:58 -0800 | [diff] [blame] | 120 | |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 121 | sec = CMOS_READ(RTC_SECONDS); |
| 122 | min = CMOS_READ(RTC_MINUTES); |
| 123 | hour = CMOS_READ(RTC_HOURS); |
| 124 | day = CMOS_READ(RTC_DAY_OF_MONTH); |
| 125 | mon = CMOS_READ(RTC_MONTH); |
| 126 | year = CMOS_READ(RTC_YEAR); |
| 127 | |
Andi Kleen | 45de707 | 2008-02-09 16:17:01 +0100 | [diff] [blame] | 128 | #ifdef CONFIG_ACPI |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 129 | if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID && |
| 130 | acpi_gbl_FADT.century) |
| 131 | century = CMOS_READ(acpi_gbl_FADT.century); |
| 132 | #endif |
| 133 | |
Andi Kleen | 068c922 | 2008-02-09 16:16:59 +0100 | [diff] [blame] | 134 | status = CMOS_READ(RTC_CONTROL); |
Andi Kleen | 45de707 | 2008-02-09 16:17:01 +0100 | [diff] [blame] | 135 | WARN_ON_ONCE(RTC_ALWAYS_BCD && (status & RTC_DM_BINARY)); |
Andi Kleen | 068c922 | 2008-02-09 16:16:59 +0100 | [diff] [blame] | 136 | |
Matt Fleming | 47997d7 | 2011-09-21 16:08:03 +0200 | [diff] [blame] | 137 | spin_unlock_irqrestore(&rtc_lock, flags); |
| 138 | |
Andi Kleen | 068c922 | 2008-02-09 16:16:59 +0100 | [diff] [blame] | 139 | if (RTC_ALWAYS_BCD || !(status & RTC_DM_BINARY)) { |
Adrian Bunk | 357c6e6 | 2008-10-18 20:28:42 -0700 | [diff] [blame] | 140 | sec = bcd2bin(sec); |
| 141 | min = bcd2bin(min); |
| 142 | hour = bcd2bin(hour); |
| 143 | day = bcd2bin(day); |
| 144 | mon = bcd2bin(mon); |
| 145 | year = bcd2bin(year); |
Matt Mackall | 41623b0 | 2006-03-28 01:56:09 -0800 | [diff] [blame] | 146 | } |
| 147 | |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 148 | if (century) { |
Adrian Bunk | 357c6e6 | 2008-10-18 20:28:42 -0700 | [diff] [blame] | 149 | century = bcd2bin(century); |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 150 | year += century * 100; |
| 151 | printk(KERN_INFO "Extended CMOS year: %d\n", century * 100); |
Andi Kleen | b62576a | 2008-02-09 16:16:58 +0100 | [diff] [blame] | 152 | } else |
Thomas Gleixner | 1122b13 | 2008-01-30 13:30:27 +0100 | [diff] [blame] | 153 | year += CMOS_YEARS_OFFS; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | |
| 155 | return mktime(year, mon, day, hour, min, sec); |
| 156 | } |
| 157 | |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 158 | /* Routines for accessing the CMOS RAM/RTC. */ |
| 159 | unsigned char rtc_cmos_read(unsigned char addr) |
| 160 | { |
| 161 | unsigned char val; |
| 162 | |
| 163 | lock_cmos_prefix(addr); |
David P. Reed | 04aaa7b | 2008-02-17 16:56:39 -0500 | [diff] [blame] | 164 | outb(addr, RTC_PORT(0)); |
| 165 | val = inb(RTC_PORT(1)); |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 166 | lock_cmos_suffix(addr); |
Jaswinder Singh Rajput | 8383d82 | 2009-03-21 16:56:37 +0530 | [diff] [blame] | 167 | |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 168 | return val; |
| 169 | } |
| 170 | EXPORT_SYMBOL(rtc_cmos_read); |
| 171 | |
| 172 | void rtc_cmos_write(unsigned char val, unsigned char addr) |
| 173 | { |
| 174 | lock_cmos_prefix(addr); |
David P. Reed | 04aaa7b | 2008-02-17 16:56:39 -0500 | [diff] [blame] | 175 | outb(addr, RTC_PORT(0)); |
| 176 | outb(val, RTC_PORT(1)); |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 177 | lock_cmos_suffix(addr); |
| 178 | } |
| 179 | EXPORT_SYMBOL(rtc_cmos_write); |
| 180 | |
Feng Tang | 7bd867d | 2009-09-10 10:48:56 +0800 | [diff] [blame] | 181 | int update_persistent_clock(struct timespec now) |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 182 | { |
Matt Fleming | 47997d7 | 2011-09-21 16:08:03 +0200 | [diff] [blame] | 183 | return x86_platform.set_wallclock(now.tv_sec); |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 184 | } |
| 185 | |
| 186 | /* not static: needed by APM */ |
Martin Schwidefsky | d4f587c | 2009-08-14 15:47:31 +0200 | [diff] [blame] | 187 | void read_persistent_clock(struct timespec *ts) |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 188 | { |
Matt Fleming | 47997d7 | 2011-09-21 16:08:03 +0200 | [diff] [blame] | 189 | unsigned long retval; |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 190 | |
Feng Tang | 7bd867d | 2009-09-10 10:48:56 +0800 | [diff] [blame] | 191 | retval = x86_platform.get_wallclock(); |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 192 | |
Martin Schwidefsky | d4f587c | 2009-08-14 15:47:31 +0200 | [diff] [blame] | 193 | ts->tv_sec = retval; |
| 194 | ts->tv_nsec = 0; |
Thomas Gleixner | fe599f9 | 2008-01-30 13:30:26 +0100 | [diff] [blame] | 195 | } |
| 196 | |
Ingo Molnar | 92767af | 2008-01-30 13:32:40 +0100 | [diff] [blame] | 197 | unsigned long long native_read_tsc(void) |
Ingo Molnar | cdc7957 | 2008-01-30 13:32:39 +0100 | [diff] [blame] | 198 | { |
Ingo Molnar | 92767af | 2008-01-30 13:32:40 +0100 | [diff] [blame] | 199 | return __native_read_tsc(); |
Ingo Molnar | cdc7957 | 2008-01-30 13:32:39 +0100 | [diff] [blame] | 200 | } |
Ingo Molnar | 92767af | 2008-01-30 13:32:40 +0100 | [diff] [blame] | 201 | EXPORT_SYMBOL(native_read_tsc); |
| 202 | |
Stas Sergeev | 1da2e3d | 2008-06-12 15:21:54 -0700 | [diff] [blame] | 203 | |
| 204 | static struct resource rtc_resources[] = { |
| 205 | [0] = { |
| 206 | .start = RTC_PORT(0), |
| 207 | .end = RTC_PORT(1), |
| 208 | .flags = IORESOURCE_IO, |
| 209 | }, |
| 210 | [1] = { |
| 211 | .start = RTC_IRQ, |
| 212 | .end = RTC_IRQ, |
| 213 | .flags = IORESOURCE_IRQ, |
| 214 | } |
| 215 | }; |
| 216 | |
| 217 | static struct platform_device rtc_device = { |
| 218 | .name = "rtc_cmos", |
| 219 | .id = -1, |
| 220 | .resource = rtc_resources, |
| 221 | .num_resources = ARRAY_SIZE(rtc_resources), |
| 222 | }; |
| 223 | |
| 224 | static __init int add_rtc_cmos(void) |
| 225 | { |
| 226 | #ifdef CONFIG_PNP |
Bjorn Helgaas | 758a7f7 | 2008-10-14 17:01:03 -0600 | [diff] [blame] | 227 | static const char *ids[] __initconst = |
| 228 | { "PNP0b00", "PNP0b01", "PNP0b02", }; |
| 229 | struct pnp_dev *dev; |
| 230 | struct pnp_id *id; |
| 231 | int i; |
| 232 | |
| 233 | pnp_for_each_dev(dev) { |
| 234 | for (id = dev->id; id; id = id->next) { |
| 235 | for (i = 0; i < ARRAY_SIZE(ids); i++) { |
| 236 | if (compare_pnp_id(id, ids[i]) != 0) |
| 237 | return 0; |
| 238 | } |
| 239 | } |
| 240 | } |
| 241 | #endif |
Sebastian Andrzej Siewior | 3bcbaf6 | 2011-02-22 21:07:46 +0100 | [diff] [blame] | 242 | if (of_have_populated_dt()) |
| 243 | return 0; |
Bjorn Helgaas | 758a7f7 | 2008-10-14 17:01:03 -0600 | [diff] [blame] | 244 | |
Stas Sergeev | 1da2e3d | 2008-06-12 15:21:54 -0700 | [diff] [blame] | 245 | platform_device_register(&rtc_device); |
Bjorn Helgaas | 758a7f7 | 2008-10-14 17:01:03 -0600 | [diff] [blame] | 246 | dev_info(&rtc_device.dev, |
| 247 | "registered platform RTC device (no PNP device found)\n"); |
Jaswinder Singh Rajput | 8383d82 | 2009-03-21 16:56:37 +0530 | [diff] [blame] | 248 | |
Stas Sergeev | 1da2e3d | 2008-06-12 15:21:54 -0700 | [diff] [blame] | 249 | return 0; |
| 250 | } |
| 251 | device_initcall(add_rtc_cmos); |