mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
221 lines
4.8 KiB
221 lines
4.8 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* 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 "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) |
|
{ |
|
mc146818_get_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 0; |
|
} |
|
|
|
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 mc146818_set_time(tm); |
|
} |
|
|
|
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, |
|
.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; |
|
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 const struct rtc_class_ops remote_rtc_ops = { |
|
.read_time = remote_read_time, |
|
.set_time = remote_set_time, |
|
.ioctl = alpha_rtc_ioctl, |
|
}; |
|
#endif |
|
|
|
static int __init |
|
alpha_rtc_init(void) |
|
{ |
|
struct platform_device *pdev; |
|
struct rtc_device *rtc; |
|
|
|
init_rtc_epoch(); |
|
|
|
pdev = platform_device_register_simple("rtc-alpha", -1, NULL, 0); |
|
rtc = devm_rtc_allocate_device(&pdev->dev); |
|
if (IS_ERR(rtc)) |
|
return PTR_ERR(rtc); |
|
|
|
platform_set_drvdata(pdev, rtc); |
|
rtc->ops = &alpha_rtc_ops; |
|
|
|
#ifdef HAVE_REMOTE_RTC |
|
if (alpha_mv.rtc_boot_cpu_only) |
|
rtc->ops = &remote_rtc_ops; |
|
#endif |
|
|
|
return devm_rtc_register_device(rtc); |
|
} |
|
device_initcall(alpha_rtc_init);
|
|
|