1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * linux/arch/alpha/kernel/rtc.c
4 *
5 * Copyright (C) 1991, 1992, 1995, 1999, 2000 Linus Torvalds
6 *
7 * This file contains date handling.
8 */
9 #include <linux/errno.h>
10 #include <linux/init.h>
11 #include <linux/kernel.h>
12 #include <linux/param.h>
13 #include <linux/string.h>
14 #include <linux/mc146818rtc.h>
15 #include <linux/bcd.h>
16 #include <linux/rtc.h>
17 #include <linux/platform_device.h>
18
19 #include "proto.h"
20
21
22 /*
23 * Support for the RTC device.
24 *
25 * We don't want to use the rtc-cmos driver, because we don't want to support
26 * alarms, as that would be indistinguishable from timer interrupts.
27 *
28 * Further, generic code is really, really tied to a 1900 epoch. This is
29 * true in __get_rtc_time as well as the users of struct rtc_time e.g.
30 * rtc_tm_to_time. Thankfully all of the other epochs in use are later
31 * than 1900, and so it's easy to adjust.
32 */
33
34 static unsigned long rtc_epoch;
35
36 static int __init
37 specifiy_epoch(char *str)
38 {
39 unsigned long epoch = simple_strtoul(str, NULL, 0);
40 if (epoch < 1900)
41 printk("Ignoring invalid user specified epoch %lu\n", epoch);
42 else
43 rtc_epoch = epoch;
44 return 1;
45 }
46 __setup("epoch=", specifiy_epoch);
47
48 static void __init
49 init_rtc_epoch(void)
50 {
51 int epoch, year, ctrl;
52
53 if (rtc_epoch != 0) {
54 /* The epoch was specified on the command-line. */
55 return;
56 }
57
58 /* Detect the epoch in use on this computer. */
59 ctrl = CMOS_READ(RTC_CONTROL);
60 year = CMOS_READ(RTC_YEAR);
61 if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
62 year = bcd2bin(year);
63
64 /* PC-like is standard; used for year >= 70 */
65 epoch = 1900;
66 if (year < 20) {
67 epoch = 2000;
68 } else if (year >= 20 && year < 48) {
69 /* NT epoch */
70 epoch = 1980;
71 } else if (year >= 48 && year < 70) {
72 /* Digital UNIX epoch */
73 epoch = 1952;
74 }
75 rtc_epoch = epoch;
76
77 printk(KERN_INFO "Using epoch %d for rtc year %d\n", epoch, year);
78 }
79
80 static int
81 alpha_rtc_read_time(struct device *dev, struct rtc_time *tm)
82 {
83 int ret = mc146818_get_time(tm, 10);
84
85 if (ret < 0) {
86 dev_err_ratelimited(dev, "unable to read current time\n");
87 return ret;
88 }
89
90 /* Adjust for non-default epochs. It's easier to depend on the
91 generic __get_rtc_time and adjust the epoch here than create
92 a copy of __get_rtc_time with the edits we need. */
93 if (rtc_epoch != 1900) {
94 int year = tm->tm_year;
95 /* Undo the century adjustment made in __get_rtc_time. */
96 if (year >= 100)
97 year -= 100;
98 year += rtc_epoch - 1900;
99 /* Redo the century adjustment with the epoch in place. */
100 if (year <= 69)
101 year += 100;
102 tm->tm_year = year;
103 }
104
105 return 0;
106 }
107
108 static int
109 alpha_rtc_set_time(struct device *dev, struct rtc_time *tm)
110 {
111 struct rtc_time xtm;
112
113 if (rtc_epoch != 1900) {
114 xtm = *tm;
115 xtm.tm_year -= rtc_epoch - 1900;
116 tm = &xtm;
117 }
118
119 return mc146818_set_time(tm);
120 }
121
122 static int
123 alpha_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
124 {
125 switch (cmd) {
126 case RTC_EPOCH_READ:
127 return put_user(rtc_epoch, (unsigned long __user *)arg);
128 case RTC_EPOCH_SET:
129 if (arg < 1900)
130 return -EINVAL;
131 rtc_epoch = arg;
132 return 0;
133 default:
134 return -ENOIOCTLCMD;
135 }
136 }
137
138 static const struct rtc_class_ops alpha_rtc_ops = {
139 .read_time = alpha_rtc_read_time,
140 .set_time = alpha_rtc_set_time,
141 .ioctl = alpha_rtc_ioctl,
142 };
143
144 /*
145 * Similarly, except do the actual CMOS access on the boot cpu only.
146 * This requires marshalling the data across an interprocessor call.
147 */
148
149 #if defined(CONFIG_SMP) && \
150 (defined(CONFIG_ALPHA_GENERIC) || defined(CONFIG_ALPHA_MARVEL))
151 # define HAVE_REMOTE_RTC 1
152
153 union remote_data {
154 struct rtc_time *tm;
155 long retval;
156 };
157
158 static void
159 do_remote_read(void *data)
160 {
161 union remote_data *x = data;
162 x->retval = alpha_rtc_read_time(NULL, x->tm);
163 }
164
165 static int
166 remote_read_time(struct device *dev, struct rtc_time *tm)
167 {
168 union remote_data x;
169 if (smp_processor_id() != boot_cpuid) {
170 x.tm = tm;
171 smp_call_function_single(boot_cpuid, do_remote_read, &x, 1);
172 return x.retval;
173 }
174 return alpha_rtc_read_time(NULL, tm);
175 }
176
177 static void
178 do_remote_set(void *data)
179 {
180 union remote_data *x = data;
181 x->retval = alpha_rtc_set_time(NULL, x->tm);
182 }
183
184 static int
185 remote_set_time(struct device *dev, struct rtc_time *tm)
186 {
187 union remote_data x;
188 if (smp_processor_id() != boot_cpuid) {
189 x.tm = tm;
190 smp_call_function_single(boot_cpuid, do_remote_set, &x, 1);
191 return x.retval;
192 }
193 return alpha_rtc_set_time(NULL, tm);
194 }
195
196 static const struct rtc_class_ops remote_rtc_ops = {
197 .read_time = remote_read_time,
198 .set_time = remote_set_time,
199 .ioctl = alpha_rtc_ioctl,
200 };
201 #endif
202
203 static int __init
204 alpha_rtc_init(void)
205 {
206 struct platform_device *pdev;
207 struct rtc_device *rtc;
208
209 init_rtc_epoch();
210
211 pdev = platform_device_register_simple("rtc-alpha", -1, NULL, 0);
212 rtc = devm_rtc_allocate_device(&pdev->dev);
213 if (IS_ERR(rtc))
214 return PTR_ERR(rtc);
215
216 platform_set_drvdata(pdev, rtc);
217 rtc->ops = &alpha_rtc_ops;
218
219 #ifdef HAVE_REMOTE_RTC
220 if (alpha_mv.rtc_boot_cpu_only)
221 rtc->ops = &remote_rtc_ops;
222 #endif
223
224 return devm_rtc_register_device(rtc);
225 }
226 device_initcall(alpha_rtc_init);
227
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.