Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227// 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 __initspecifiy_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 __initinit_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 intalpha_rtc_read_time(struct device *dev, struct rtc_time *tm){ int ret = mc146818_get_time(tm, 10);
if (ret < 0) { dev_err_ratelimited(dev, "unable to read current time\n"); return ret; }
/* 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 intalpha_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 intalpha_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 voiddo_remote_read(void *data){ union remote_data *x = data; x->retval = alpha_rtc_read_time(NULL, x->tm);}
static intremote_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 voiddo_remote_set(void *data){ union remote_data *x = data; x->retval = alpha_rtc_set_time(NULL, x->tm);}
static intremote_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 __initalpha_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);