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(time: tm, timeout: 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(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(name: "rtc-alpha" , id: -1, NULL, num: 0); |
212 | rtc = devm_rtc_allocate_device(dev: &pdev->dev); |
213 | if (IS_ERR(ptr: rtc)) |
214 | return PTR_ERR(ptr: rtc); |
215 | |
216 | platform_set_drvdata(pdev, data: 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 | |