| 1 | /* |
| 2 | * RTC related functions |
| 3 | */ |
| 4 | #include <linux/platform_device.h> |
| 5 | #include <linux/mc146818rtc.h> |
| 6 | #include <linux/acpi.h> |
| 7 | #include <linux/bcd.h> |
| 8 | #include <linux/export.h> |
| 9 | #include <linux/pnp.h> |
| 10 | #include <linux/of.h> |
| 11 | |
| 12 | #include <asm/vsyscall.h> |
| 13 | #include <asm/x86_init.h> |
| 14 | #include <asm/time.h> |
| 15 | #include <asm/intel-mid.h> |
| 16 | #include <asm/rtc.h> |
| 17 | #include <asm/setup.h> |
| 18 | |
| 19 | #ifdef CONFIG_X86_32 |
| 20 | /* |
| 21 | * This is a special lock that is owned by the CPU and holds the index |
| 22 | * register we are working with. It is required for NMI access to the |
| 23 | * CMOS/RTC registers. See include/asm-i386/mc146818rtc.h for details. |
| 24 | */ |
| 25 | volatile unsigned long cmos_lock; |
| 26 | EXPORT_SYMBOL(cmos_lock); |
| 27 | #endif /* CONFIG_X86_32 */ |
| 28 | |
| 29 | /* For two digit years assume time is always after that */ |
| 30 | #define CMOS_YEARS_OFFS 2000 |
| 31 | |
| 32 | DEFINE_SPINLOCK(rtc_lock); |
| 33 | EXPORT_SYMBOL(rtc_lock); |
| 34 | |
| 35 | /* |
| 36 | * In order to set the CMOS clock precisely, set_rtc_mmss has to be |
| 37 | * called 500 ms after the second nowtime has started, because when |
| 38 | * nowtime is written into the registers of the CMOS clock, it will |
| 39 | * jump to the next second precisely 500 ms later. Check the Motorola |
| 40 | * MC146818A or Dallas DS12887 data sheet for details. |
| 41 | */ |
| 42 | int mach_set_rtc_mmss(const struct timespec *now) |
| 43 | { |
| 44 | unsigned long nowtime = now->tv_sec; |
| 45 | struct rtc_time tm; |
| 46 | int retval = 0; |
| 47 | |
| 48 | rtc_time_to_tm(nowtime, &tm); |
| 49 | if (!rtc_valid_tm(&tm)) { |
| 50 | retval = set_rtc_time(&tm); |
| 51 | if (retval) |
| 52 | printk(KERN_ERR "%s: RTC write failed with error %d\n", |
| 53 | __func__, retval); |
| 54 | } else { |
| 55 | printk(KERN_ERR |
| 56 | "%s: Invalid RTC value: write of %lx to RTC failed\n", |
| 57 | __func__, nowtime); |
| 58 | retval = -EINVAL; |
| 59 | } |
| 60 | return retval; |
| 61 | } |
| 62 | |
| 63 | void mach_get_cmos_time(struct timespec *now) |
| 64 | { |
| 65 | unsigned int status, year, mon, day, hour, min, sec, century = 0; |
| 66 | unsigned long flags; |
| 67 | |
| 68 | spin_lock_irqsave(&rtc_lock, flags); |
| 69 | |
| 70 | /* |
| 71 | * If UIP is clear, then we have >= 244 microseconds before |
| 72 | * RTC registers will be updated. Spec sheet says that this |
| 73 | * is the reliable way to read RTC - registers. If UIP is set |
| 74 | * then the register access might be invalid. |
| 75 | */ |
| 76 | while ((CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP)) |
| 77 | cpu_relax(); |
| 78 | |
| 79 | sec = CMOS_READ(RTC_SECONDS); |
| 80 | min = CMOS_READ(RTC_MINUTES); |
| 81 | hour = CMOS_READ(RTC_HOURS); |
| 82 | day = CMOS_READ(RTC_DAY_OF_MONTH); |
| 83 | mon = CMOS_READ(RTC_MONTH); |
| 84 | year = CMOS_READ(RTC_YEAR); |
| 85 | |
| 86 | #ifdef CONFIG_ACPI |
| 87 | if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID && |
| 88 | acpi_gbl_FADT.century) |
| 89 | century = CMOS_READ(acpi_gbl_FADT.century); |
| 90 | #endif |
| 91 | |
| 92 | status = CMOS_READ(RTC_CONTROL); |
| 93 | WARN_ON_ONCE(RTC_ALWAYS_BCD && (status & RTC_DM_BINARY)); |
| 94 | |
| 95 | spin_unlock_irqrestore(&rtc_lock, flags); |
| 96 | |
| 97 | if (RTC_ALWAYS_BCD || !(status & RTC_DM_BINARY)) { |
| 98 | sec = bcd2bin(sec); |
| 99 | min = bcd2bin(min); |
| 100 | hour = bcd2bin(hour); |
| 101 | day = bcd2bin(day); |
| 102 | mon = bcd2bin(mon); |
| 103 | year = bcd2bin(year); |
| 104 | } |
| 105 | |
| 106 | if (century) { |
| 107 | century = bcd2bin(century); |
| 108 | year += century * 100; |
| 109 | } else |
| 110 | year += CMOS_YEARS_OFFS; |
| 111 | |
| 112 | now->tv_sec = mktime(year, mon, day, hour, min, sec); |
| 113 | now->tv_nsec = 0; |
| 114 | } |
| 115 | |
| 116 | /* Routines for accessing the CMOS RAM/RTC. */ |
| 117 | unsigned char rtc_cmos_read(unsigned char addr) |
| 118 | { |
| 119 | unsigned char val; |
| 120 | |
| 121 | lock_cmos_prefix(addr); |
| 122 | outb(addr, RTC_PORT(0)); |
| 123 | val = inb(RTC_PORT(1)); |
| 124 | lock_cmos_suffix(addr); |
| 125 | |
| 126 | return val; |
| 127 | } |
| 128 | EXPORT_SYMBOL(rtc_cmos_read); |
| 129 | |
| 130 | void rtc_cmos_write(unsigned char val, unsigned char addr) |
| 131 | { |
| 132 | lock_cmos_prefix(addr); |
| 133 | outb(addr, RTC_PORT(0)); |
| 134 | outb(val, RTC_PORT(1)); |
| 135 | lock_cmos_suffix(addr); |
| 136 | } |
| 137 | EXPORT_SYMBOL(rtc_cmos_write); |
| 138 | |
| 139 | int update_persistent_clock(struct timespec now) |
| 140 | { |
| 141 | return x86_platform.set_wallclock(&now); |
| 142 | } |
| 143 | |
| 144 | /* not static: needed by APM */ |
| 145 | void read_persistent_clock(struct timespec *ts) |
| 146 | { |
| 147 | x86_platform.get_wallclock(ts); |
| 148 | } |
| 149 | |
| 150 | |
| 151 | static struct resource rtc_resources[] = { |
| 152 | [0] = { |
| 153 | .start = RTC_PORT(0), |
| 154 | .end = RTC_PORT(1), |
| 155 | .flags = IORESOURCE_IO, |
| 156 | }, |
| 157 | [1] = { |
| 158 | .start = RTC_IRQ, |
| 159 | .end = RTC_IRQ, |
| 160 | .flags = IORESOURCE_IRQ, |
| 161 | } |
| 162 | }; |
| 163 | |
| 164 | static struct platform_device rtc_device = { |
| 165 | .name = "rtc_cmos", |
| 166 | .id = -1, |
| 167 | .resource = rtc_resources, |
| 168 | .num_resources = ARRAY_SIZE(rtc_resources), |
| 169 | }; |
| 170 | |
| 171 | static __init int add_rtc_cmos(void) |
| 172 | { |
| 173 | #ifdef CONFIG_PNP |
| 174 | static const char * const ids[] __initconst = |
| 175 | { "PNP0b00", "PNP0b01", "PNP0b02", }; |
| 176 | struct pnp_dev *dev; |
| 177 | struct pnp_id *id; |
| 178 | int i; |
| 179 | |
| 180 | pnp_for_each_dev(dev) { |
| 181 | for (id = dev->id; id; id = id->next) { |
| 182 | for (i = 0; i < ARRAY_SIZE(ids); i++) { |
| 183 | if (compare_pnp_id(id, ids[i]) != 0) |
| 184 | return 0; |
| 185 | } |
| 186 | } |
| 187 | } |
| 188 | #endif |
| 189 | if (!x86_platform.legacy.rtc) |
| 190 | return -ENODEV; |
| 191 | |
| 192 | platform_device_register(&rtc_device); |
| 193 | dev_info(&rtc_device.dev, |
| 194 | "registered platform RTC device (no PNP device found)\n"); |
| 195 | |
| 196 | return 0; |
| 197 | } |
| 198 | device_initcall(add_rtc_cmos); |