mirror of
https://github.com/FEX-Emu/linux.git
synced 2024-12-29 04:45:05 +00:00
3195ef59cb
Every 11 minutes ntp attempts to update the x86 rtc with the current system time. Currently, the x86 code only updates the rtc if the system time is within +/-15 minutes of the current value of the rtc. This was done originally to avoid setting the RTC if the RTC was in localtime mode (common with Windows dualbooting). Other architectures do a full synchronization and now that we have better infrastructure to detect when the RTC is in localtime, there is no reason that x86 should be software limited to a 30 minute window. This patch changes the behavior of the kernel to do a full synchronization (year, month, day, hour, minute, and second) of the rtc when ntp requests a synchronization between the system time and the rtc. I've used the RTC library functions in this patchset as they do all the required bounds checking. Cc: Thomas Gleixner <tglx@linutronix.de> Cc: John Stultz <john.stultz@linaro.org> Cc: x86@kernel.org Cc: Matt Fleming <matt.fleming@intel.com> Cc: David Vrabel <david.vrabel@citrix.com> Cc: Andrew Morton <akpm@linux-foundation.org> Cc: Andi Kleen <ak@linux.intel.com> Cc: linux-efi@vger.kernel.org Signed-off-by: Prarit Bhargava <prarit@redhat.com> [jstultz: Tweak commit message, fold in build fix found by fengguang Also add select RTC_LIB to X86, per new dependency, as found by prarit] Signed-off-by: John Stultz <john.stultz@linaro.org>
205 lines
4.6 KiB
C
205 lines
4.6 KiB
C
/*
|
|
* RTC related functions
|
|
*/
|
|
#include <linux/platform_device.h>
|
|
#include <linux/mc146818rtc.h>
|
|
#include <linux/acpi.h>
|
|
#include <linux/bcd.h>
|
|
#include <linux/export.h>
|
|
#include <linux/pnp.h>
|
|
#include <linux/of.h>
|
|
|
|
#include <asm/vsyscall.h>
|
|
#include <asm/x86_init.h>
|
|
#include <asm/time.h>
|
|
#include <asm/mrst.h>
|
|
#include <asm/rtc.h>
|
|
|
|
#ifdef CONFIG_X86_32
|
|
/*
|
|
* This is a special lock that is owned by the CPU and holds the index
|
|
* register we are working with. It is required for NMI access to the
|
|
* CMOS/RTC registers. See include/asm-i386/mc146818rtc.h for details.
|
|
*/
|
|
volatile unsigned long cmos_lock;
|
|
EXPORT_SYMBOL(cmos_lock);
|
|
#endif /* CONFIG_X86_32 */
|
|
|
|
/* For two digit years assume time is always after that */
|
|
#define CMOS_YEARS_OFFS 2000
|
|
|
|
DEFINE_SPINLOCK(rtc_lock);
|
|
EXPORT_SYMBOL(rtc_lock);
|
|
|
|
/*
|
|
* In order to set the CMOS clock precisely, set_rtc_mmss has to be
|
|
* called 500 ms after the second nowtime has started, because when
|
|
* nowtime is written into the registers of the CMOS clock, it will
|
|
* jump to the next second precisely 500 ms later. Check the Motorola
|
|
* MC146818A or Dallas DS12887 data sheet for details.
|
|
*/
|
|
int mach_set_rtc_mmss(unsigned long nowtime)
|
|
{
|
|
struct rtc_time tm;
|
|
int retval = 0;
|
|
|
|
rtc_time_to_tm(nowtime, &tm);
|
|
if (!rtc_valid_tm(&tm)) {
|
|
retval = set_rtc_time(&tm);
|
|
if (retval)
|
|
printk(KERN_ERR "%s: RTC write failed with error %d\n",
|
|
__FUNCTION__, retval);
|
|
} else {
|
|
printk(KERN_ERR
|
|
"%s: Invalid RTC value: write of %lx to RTC failed\n",
|
|
__FUNCTION__, nowtime);
|
|
retval = -EINVAL;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
unsigned long mach_get_cmos_time(void)
|
|
{
|
|
unsigned int status, year, mon, day, hour, min, sec, century = 0;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&rtc_lock, flags);
|
|
|
|
/*
|
|
* If UIP is clear, then we have >= 244 microseconds before
|
|
* RTC registers will be updated. Spec sheet says that this
|
|
* is the reliable way to read RTC - registers. If UIP is set
|
|
* then the register access might be invalid.
|
|
*/
|
|
while ((CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP))
|
|
cpu_relax();
|
|
|
|
sec = CMOS_READ(RTC_SECONDS);
|
|
min = CMOS_READ(RTC_MINUTES);
|
|
hour = CMOS_READ(RTC_HOURS);
|
|
day = CMOS_READ(RTC_DAY_OF_MONTH);
|
|
mon = CMOS_READ(RTC_MONTH);
|
|
year = CMOS_READ(RTC_YEAR);
|
|
|
|
#ifdef CONFIG_ACPI
|
|
if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID &&
|
|
acpi_gbl_FADT.century)
|
|
century = CMOS_READ(acpi_gbl_FADT.century);
|
|
#endif
|
|
|
|
status = CMOS_READ(RTC_CONTROL);
|
|
WARN_ON_ONCE(RTC_ALWAYS_BCD && (status & RTC_DM_BINARY));
|
|
|
|
spin_unlock_irqrestore(&rtc_lock, flags);
|
|
|
|
if (RTC_ALWAYS_BCD || !(status & RTC_DM_BINARY)) {
|
|
sec = bcd2bin(sec);
|
|
min = bcd2bin(min);
|
|
hour = bcd2bin(hour);
|
|
day = bcd2bin(day);
|
|
mon = bcd2bin(mon);
|
|
year = bcd2bin(year);
|
|
}
|
|
|
|
if (century) {
|
|
century = bcd2bin(century);
|
|
year += century * 100;
|
|
} else
|
|
year += CMOS_YEARS_OFFS;
|
|
|
|
return mktime(year, mon, day, hour, min, sec);
|
|
}
|
|
|
|
/* Routines for accessing the CMOS RAM/RTC. */
|
|
unsigned char rtc_cmos_read(unsigned char addr)
|
|
{
|
|
unsigned char val;
|
|
|
|
lock_cmos_prefix(addr);
|
|
outb(addr, RTC_PORT(0));
|
|
val = inb(RTC_PORT(1));
|
|
lock_cmos_suffix(addr);
|
|
|
|
return val;
|
|
}
|
|
EXPORT_SYMBOL(rtc_cmos_read);
|
|
|
|
void rtc_cmos_write(unsigned char val, unsigned char addr)
|
|
{
|
|
lock_cmos_prefix(addr);
|
|
outb(addr, RTC_PORT(0));
|
|
outb(val, RTC_PORT(1));
|
|
lock_cmos_suffix(addr);
|
|
}
|
|
EXPORT_SYMBOL(rtc_cmos_write);
|
|
|
|
int update_persistent_clock(struct timespec now)
|
|
{
|
|
return x86_platform.set_wallclock(now.tv_sec);
|
|
}
|
|
|
|
/* not static: needed by APM */
|
|
void read_persistent_clock(struct timespec *ts)
|
|
{
|
|
unsigned long retval;
|
|
|
|
retval = x86_platform.get_wallclock();
|
|
|
|
ts->tv_sec = retval;
|
|
ts->tv_nsec = 0;
|
|
}
|
|
|
|
|
|
static struct resource rtc_resources[] = {
|
|
[0] = {
|
|
.start = RTC_PORT(0),
|
|
.end = RTC_PORT(1),
|
|
.flags = IORESOURCE_IO,
|
|
},
|
|
[1] = {
|
|
.start = RTC_IRQ,
|
|
.end = RTC_IRQ,
|
|
.flags = IORESOURCE_IRQ,
|
|
}
|
|
};
|
|
|
|
static struct platform_device rtc_device = {
|
|
.name = "rtc_cmos",
|
|
.id = -1,
|
|
.resource = rtc_resources,
|
|
.num_resources = ARRAY_SIZE(rtc_resources),
|
|
};
|
|
|
|
static __init int add_rtc_cmos(void)
|
|
{
|
|
#ifdef CONFIG_PNP
|
|
static const char * const const ids[] __initconst =
|
|
{ "PNP0b00", "PNP0b01", "PNP0b02", };
|
|
struct pnp_dev *dev;
|
|
struct pnp_id *id;
|
|
int i;
|
|
|
|
pnp_for_each_dev(dev) {
|
|
for (id = dev->id; id; id = id->next) {
|
|
for (i = 0; i < ARRAY_SIZE(ids); i++) {
|
|
if (compare_pnp_id(id, ids[i]) != 0)
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
if (of_have_populated_dt())
|
|
return 0;
|
|
|
|
/* Intel MID platforms don't have ioport rtc */
|
|
if (mrst_identify_cpu())
|
|
return -ENODEV;
|
|
|
|
platform_device_register(&rtc_device);
|
|
dev_info(&rtc_device.dev,
|
|
"registered platform RTC device (no PNP device found)\n");
|
|
|
|
return 0;
|
|
}
|
|
device_initcall(add_rtc_cmos);
|