mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-04 09:59:32 +00:00
![Richard Henderson](/assets/img/avatar_default.png)
Discontinue use of GENERIC_CMOS_UPDATE; rely on the RTC subsystem. The marvel platform requires that the rtc only be touched from the boot cpu. This had been partially implemented with hooks for get/set_rtc_time, but read/update_persistent_clock were not handled. Move the hooks from the machine_vec to a special rtc_class_ops struct. We had read_persistent_clock managing the epoch against which the rtc hw is based, but this didn't apply to get_rtc_time or set_rtc_time. This resulted in incorrect values when hwclock(8) gets involved. Allow the epoch to be set from the kernel command-line, overriding the autodetection, which is doomed to fail in 2020. Further, by implementing the rtc ioctl function, we can expose this epoch to userland. Elide the alarm functions that RTC_DRV_CMOS implements. This was highly questionable on Alpha, since the interrupt is used by the system timer. Signed-off-by: Richard Henderson <rth@twiddle.net>
323 lines
8 KiB
C
323 lines
8 KiB
C
/*
|
|
* linux/arch/alpha/kernel/rtc.c
|
|
*
|
|
* Copyright (C) 1991, 1992, 1995, 1999, 2000 Linus Torvalds
|
|
*
|
|
* This file contains date handling.
|
|
*/
|
|
#include <linux/errno.h>
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/param.h>
|
|
#include <linux/string.h>
|
|
#include <linux/mc146818rtc.h>
|
|
#include <linux/bcd.h>
|
|
#include <linux/rtc.h>
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <asm/rtc.h>
|
|
|
|
#include "proto.h"
|
|
|
|
|
|
/*
|
|
* Support for the RTC device.
|
|
*
|
|
* We don't want to use the rtc-cmos driver, because we don't want to support
|
|
* alarms, as that would be indistinguishable from timer interrupts.
|
|
*
|
|
* Further, generic code is really, really tied to a 1900 epoch. This is
|
|
* true in __get_rtc_time as well as the users of struct rtc_time e.g.
|
|
* rtc_tm_to_time. Thankfully all of the other epochs in use are later
|
|
* than 1900, and so it's easy to adjust.
|
|
*/
|
|
|
|
static unsigned long rtc_epoch;
|
|
|
|
static int __init
|
|
specifiy_epoch(char *str)
|
|
{
|
|
unsigned long epoch = simple_strtoul(str, NULL, 0);
|
|
if (epoch < 1900)
|
|
printk("Ignoring invalid user specified epoch %lu\n", epoch);
|
|
else
|
|
rtc_epoch = epoch;
|
|
return 1;
|
|
}
|
|
__setup("epoch=", specifiy_epoch);
|
|
|
|
static void __init
|
|
init_rtc_epoch(void)
|
|
{
|
|
int epoch, year, ctrl;
|
|
|
|
if (rtc_epoch != 0) {
|
|
/* The epoch was specified on the command-line. */
|
|
return;
|
|
}
|
|
|
|
/* Detect the epoch in use on this computer. */
|
|
ctrl = CMOS_READ(RTC_CONTROL);
|
|
year = CMOS_READ(RTC_YEAR);
|
|
if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
|
|
year = bcd2bin(year);
|
|
|
|
/* PC-like is standard; used for year >= 70 */
|
|
epoch = 1900;
|
|
if (year < 20) {
|
|
epoch = 2000;
|
|
} else if (year >= 20 && year < 48) {
|
|
/* NT epoch */
|
|
epoch = 1980;
|
|
} else if (year >= 48 && year < 70) {
|
|
/* Digital UNIX epoch */
|
|
epoch = 1952;
|
|
}
|
|
rtc_epoch = epoch;
|
|
|
|
printk(KERN_INFO "Using epoch %d for rtc year %d\n", epoch, year);
|
|
}
|
|
|
|
static int
|
|
alpha_rtc_read_time(struct device *dev, struct rtc_time *tm)
|
|
{
|
|
__get_rtc_time(tm);
|
|
|
|
/* Adjust for non-default epochs. It's easier to depend on the
|
|
generic __get_rtc_time and adjust the epoch here than create
|
|
a copy of __get_rtc_time with the edits we need. */
|
|
if (rtc_epoch != 1900) {
|
|
int year = tm->tm_year;
|
|
/* Undo the century adjustment made in __get_rtc_time. */
|
|
if (year >= 100)
|
|
year -= 100;
|
|
year += rtc_epoch - 1900;
|
|
/* Redo the century adjustment with the epoch in place. */
|
|
if (year <= 69)
|
|
year += 100;
|
|
tm->tm_year = year;
|
|
}
|
|
|
|
return rtc_valid_tm(tm);
|
|
}
|
|
|
|
static int
|
|
alpha_rtc_set_time(struct device *dev, struct rtc_time *tm)
|
|
{
|
|
struct rtc_time xtm;
|
|
|
|
if (rtc_epoch != 1900) {
|
|
xtm = *tm;
|
|
xtm.tm_year -= rtc_epoch - 1900;
|
|
tm = &xtm;
|
|
}
|
|
|
|
return __set_rtc_time(tm);
|
|
}
|
|
|
|
static int
|
|
alpha_rtc_set_mmss(struct device *dev, unsigned long nowtime)
|
|
{
|
|
int retval = 0;
|
|
int real_seconds, real_minutes, cmos_minutes;
|
|
unsigned char save_control, save_freq_select;
|
|
|
|
/* Note: This code only updates minutes and seconds. Comments
|
|
indicate this was to avoid messing with unknown time zones,
|
|
and with the epoch nonsense described above. In order for
|
|
this to work, the existing clock cannot be off by more than
|
|
15 minutes.
|
|
|
|
??? This choice is may be out of date. The x86 port does
|
|
not have problems with timezones, and the epoch processing has
|
|
now been fixed in alpha_set_rtc_time.
|
|
|
|
In either case, one can always force a full rtc update with
|
|
the userland hwclock program, so surely 15 minute accuracy
|
|
is no real burden. */
|
|
|
|
/* In order to set the CMOS clock precisely, we have 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. */
|
|
|
|
/* irq are locally disabled here */
|
|
spin_lock(&rtc_lock);
|
|
/* Tell the clock it's being set */
|
|
save_control = CMOS_READ(RTC_CONTROL);
|
|
CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
|
|
|
|
/* Stop and reset prescaler */
|
|
save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
|
|
CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
|
|
|
|
cmos_minutes = CMOS_READ(RTC_MINUTES);
|
|
if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
|
|
cmos_minutes = bcd2bin(cmos_minutes);
|
|
|
|
real_seconds = nowtime % 60;
|
|
real_minutes = nowtime / 60;
|
|
if (((abs(real_minutes - cmos_minutes) + 15) / 30) & 1) {
|
|
/* correct for half hour time zone */
|
|
real_minutes += 30;
|
|
}
|
|
real_minutes %= 60;
|
|
|
|
if (abs(real_minutes - cmos_minutes) < 30) {
|
|
if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
|
|
real_seconds = bin2bcd(real_seconds);
|
|
real_minutes = bin2bcd(real_minutes);
|
|
}
|
|
CMOS_WRITE(real_seconds,RTC_SECONDS);
|
|
CMOS_WRITE(real_minutes,RTC_MINUTES);
|
|
} else {
|
|
printk_once(KERN_NOTICE
|
|
"set_rtc_mmss: can't update from %d to %d\n",
|
|
cmos_minutes, real_minutes);
|
|
retval = -1;
|
|
}
|
|
|
|
/* The following flags have to be released exactly in this order,
|
|
* otherwise the DS12887 (popular MC146818A clone with integrated
|
|
* battery and quartz) will not reset the oscillator and will not
|
|
* update precisely 500 ms later. You won't find this mentioned in
|
|
* the Dallas Semiconductor data sheets, but who believes data
|
|
* sheets anyway ... -- Markus Kuhn
|
|
*/
|
|
CMOS_WRITE(save_control, RTC_CONTROL);
|
|
CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
|
|
spin_unlock(&rtc_lock);
|
|
|
|
return retval;
|
|
}
|
|
|
|
static int
|
|
alpha_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
|
|
{
|
|
switch (cmd) {
|
|
case RTC_EPOCH_READ:
|
|
return put_user(rtc_epoch, (unsigned long __user *)arg);
|
|
case RTC_EPOCH_SET:
|
|
if (arg < 1900)
|
|
return -EINVAL;
|
|
rtc_epoch = arg;
|
|
return 0;
|
|
default:
|
|
return -ENOIOCTLCMD;
|
|
}
|
|
}
|
|
|
|
static const struct rtc_class_ops alpha_rtc_ops = {
|
|
.read_time = alpha_rtc_read_time,
|
|
.set_time = alpha_rtc_set_time,
|
|
.set_mmss = alpha_rtc_set_mmss,
|
|
.ioctl = alpha_rtc_ioctl,
|
|
};
|
|
|
|
/*
|
|
* Similarly, except do the actual CMOS access on the boot cpu only.
|
|
* This requires marshalling the data across an interprocessor call.
|
|
*/
|
|
|
|
#if defined(CONFIG_SMP) && \
|
|
(defined(CONFIG_ALPHA_GENERIC) || defined(CONFIG_ALPHA_MARVEL))
|
|
# define HAVE_REMOTE_RTC 1
|
|
|
|
union remote_data {
|
|
struct rtc_time *tm;
|
|
unsigned long now;
|
|
long retval;
|
|
};
|
|
|
|
static void
|
|
do_remote_read(void *data)
|
|
{
|
|
union remote_data *x = data;
|
|
x->retval = alpha_rtc_read_time(NULL, x->tm);
|
|
}
|
|
|
|
static int
|
|
remote_read_time(struct device *dev, struct rtc_time *tm)
|
|
{
|
|
union remote_data x;
|
|
if (smp_processor_id() != boot_cpuid) {
|
|
x.tm = tm;
|
|
smp_call_function_single(boot_cpuid, do_remote_read, &x, 1);
|
|
return x.retval;
|
|
}
|
|
return alpha_rtc_read_time(NULL, tm);
|
|
}
|
|
|
|
static void
|
|
do_remote_set(void *data)
|
|
{
|
|
union remote_data *x = data;
|
|
x->retval = alpha_rtc_set_time(NULL, x->tm);
|
|
}
|
|
|
|
static int
|
|
remote_set_time(struct device *dev, struct rtc_time *tm)
|
|
{
|
|
union remote_data x;
|
|
if (smp_processor_id() != boot_cpuid) {
|
|
x.tm = tm;
|
|
smp_call_function_single(boot_cpuid, do_remote_set, &x, 1);
|
|
return x.retval;
|
|
}
|
|
return alpha_rtc_set_time(NULL, tm);
|
|
}
|
|
|
|
static void
|
|
do_remote_mmss(void *data)
|
|
{
|
|
union remote_data *x = data;
|
|
x->retval = alpha_rtc_set_mmss(NULL, x->now);
|
|
}
|
|
|
|
static int
|
|
remote_set_mmss(struct device *dev, unsigned long now)
|
|
{
|
|
union remote_data x;
|
|
if (smp_processor_id() != boot_cpuid) {
|
|
x.now = now;
|
|
smp_call_function_single(boot_cpuid, do_remote_mmss, &x, 1);
|
|
return x.retval;
|
|
}
|
|
return alpha_rtc_set_mmss(NULL, now);
|
|
}
|
|
|
|
static const struct rtc_class_ops remote_rtc_ops = {
|
|
.read_time = remote_read_time,
|
|
.set_time = remote_set_time,
|
|
.set_mmss = remote_set_mmss,
|
|
.ioctl = alpha_rtc_ioctl,
|
|
};
|
|
#endif
|
|
|
|
static int __init
|
|
alpha_rtc_init(void)
|
|
{
|
|
const struct rtc_class_ops *ops;
|
|
struct platform_device *pdev;
|
|
struct rtc_device *rtc;
|
|
const char *name;
|
|
|
|
init_rtc_epoch();
|
|
name = "rtc-alpha";
|
|
ops = &alpha_rtc_ops;
|
|
|
|
#ifdef HAVE_REMOTE_RTC
|
|
if (alpha_mv.rtc_boot_cpu_only)
|
|
ops = &remote_rtc_ops;
|
|
#endif
|
|
|
|
pdev = platform_device_register_simple(name, -1, NULL, 0);
|
|
rtc = devm_rtc_device_register(&pdev->dev, name, ops, THIS_MODULE);
|
|
if (IS_ERR(rtc))
|
|
return PTR_ERR(rtc);
|
|
|
|
platform_set_drvdata(pdev, rtc);
|
|
return 0;
|
|
}
|
|
device_initcall(alpha_rtc_init);
|