Release 4.14 arch/alpha/kernel/rtc.c

// 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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
45
100.00%
1
100.00%
Total
45
100.00%
1
100.00%

__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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
126
100.00%
1
100.00%
Total
126
100.00%
1
100.00%


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 rtc_valid_tm(tm);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
76
98.70%
1
50.00%
Arnd Bergmann
1
1.30%
1
50.00%
Total
77
100.00%
2
100.00%


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
51
98.08%
1
50.00%
Arnd Bergmann
1
1.92%
1
50.00%
Total
52
100.00%
2
100.00%


static int

alpha_rtc_set_mmss(struct device *dev, time64_t 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
241
99.59%
1
50.00%
Xunlei Pang
1
0.41%
1
50.00%
Total
242
100.00%
2
100.00%


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;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
67
100.00%
1
100.00%
Total
67
100.00%
1
100.00%


static const struct rtc_class_ops alpha_rtc_ops = {
	.read_time = alpha_rtc_read_time,
	.set_time = alpha_rtc_set_time,
	.set_mmss64 = 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
60
100.00%
1
100.00%
Total
60
100.00%
1
100.00%


static void

do_remote_set(void *data)
{
	union remote_data *x = data;
	x->retval = alpha_rtc_set_time(NULL, x->tm);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
60
100.00%
1
100.00%
Total
60
100.00%
1
100.00%


static void

do_remote_mmss(void *data)
{
	union remote_data *x = data;
	x->retval = alpha_rtc_set_mmss(NULL, x->now);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%


static int

remote_set_mmss(struct device *dev, time64_t 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
57
98.28%
1
50.00%
Xunlei Pang
1
1.72%
1
50.00%
Total
58
100.00%
2
100.00%


static const struct rtc_class_ops remote_rtc_ops = {
	.read_time = remote_read_time,
	.set_time = remote_set_time,
	.set_mmss64 = 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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
111
100.00%
1
100.00%
Total
111
100.00%
1
100.00%


device_initcall(alpha_rtc_init);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Richard Henderson
1130
99.38%
1
25.00%
Xunlei Pang
4
0.35%
1
25.00%
Arnd Bergmann
2
0.18%
1
25.00%
Greg Kroah-Hartman
1
0.09%
1
25.00%
Total
1137
100.00%
4
100.00%
Directory: arch/alpha/kernel

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.