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