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 mc146818_get_time(tm); 84 85 /* Adjust for non-default epochs. It's easier to depend on the 86 generic __get_rtc_time and adjust the epoch here than create 87 a copy of __get_rtc_time with the edits we need. */ 88 if (rtc_epoch != 1900) { 89 int year = tm->tm_year; 90 /* Undo the century adjustment made in __get_rtc_time. */ 91 if (year >= 100) 92 year -= 100; 93 year += rtc_epoch - 1900; 94 /* Redo the century adjustment with the epoch in place. */ 95 if (year <= 69) 96 year += 100; 97 tm->tm_year = year; 98 } 99 100 return rtc_valid_tm(tm); 101 } 102 103 static int 104 alpha_rtc_set_time(struct device *dev, struct rtc_time *tm) 105 { 106 struct rtc_time xtm; 107 108 if (rtc_epoch != 1900) { 109 xtm = *tm; 110 xtm.tm_year -= rtc_epoch - 1900; 111 tm = &xtm; 112 } 113 114 return mc146818_set_time(tm); 115 } 116 117 static int 118 alpha_rtc_set_mmss(struct device *dev, time64_t nowtime) 119 { 120 int retval = 0; 121 int real_seconds, real_minutes, cmos_minutes; 122 unsigned char save_control, save_freq_select; 123 124 /* Note: This code only updates minutes and seconds. Comments 125 indicate this was to avoid messing with unknown time zones, 126 and with the epoch nonsense described above. In order for 127 this to work, the existing clock cannot be off by more than 128 15 minutes. 129 130 ??? This choice is may be out of date. The x86 port does 131 not have problems with timezones, and the epoch processing has 132 now been fixed in alpha_set_rtc_time. 133 134 In either case, one can always force a full rtc update with 135 the userland hwclock program, so surely 15 minute accuracy 136 is no real burden. */ 137 138 /* In order to set the CMOS clock precisely, we have to be called 139 500 ms after the second nowtime has started, because when 140 nowtime is written into the registers of the CMOS clock, it will 141 jump to the next second precisely 500 ms later. Check the Motorola 142 MC146818A or Dallas DS12887 data sheet for details. */ 143 144 /* irq are locally disabled here */ 145 spin_lock(&rtc_lock); 146 /* Tell the clock it's being set */ 147 save_control = CMOS_READ(RTC_CONTROL); 148 CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL); 149 150 /* Stop and reset prescaler */ 151 save_freq_select = CMOS_READ(RTC_FREQ_SELECT); 152 CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT); 153 154 cmos_minutes = CMOS_READ(RTC_MINUTES); 155 if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) 156 cmos_minutes = bcd2bin(cmos_minutes); 157 158 real_seconds = nowtime % 60; 159 real_minutes = nowtime / 60; 160 if (((abs(real_minutes - cmos_minutes) + 15) / 30) & 1) { 161 /* correct for half hour time zone */ 162 real_minutes += 30; 163 } 164 real_minutes %= 60; 165 166 if (abs(real_minutes - cmos_minutes) < 30) { 167 if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) { 168 real_seconds = bin2bcd(real_seconds); 169 real_minutes = bin2bcd(real_minutes); 170 } 171 CMOS_WRITE(real_seconds,RTC_SECONDS); 172 CMOS_WRITE(real_minutes,RTC_MINUTES); 173 } else { 174 printk_once(KERN_NOTICE 175 "set_rtc_mmss: can't update from %d to %d\n", 176 cmos_minutes, real_minutes); 177 retval = -1; 178 } 179 180 /* The following flags have to be released exactly in this order, 181 * otherwise the DS12887 (popular MC146818A clone with integrated 182 * battery and quartz) will not reset the oscillator and will not 183 * update precisely 500 ms later. You won't find this mentioned in 184 * the Dallas Semiconductor data sheets, but who believes data 185 * sheets anyway ... -- Markus Kuhn 186 */ 187 CMOS_WRITE(save_control, RTC_CONTROL); 188 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT); 189 spin_unlock(&rtc_lock); 190 191 return retval; 192 } 193 194 static int 195 alpha_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 196 { 197 switch (cmd) { 198 case RTC_EPOCH_READ: 199 return put_user(rtc_epoch, (unsigned long __user *)arg); 200 case RTC_EPOCH_SET: 201 if (arg < 1900) 202 return -EINVAL; 203 rtc_epoch = arg; 204 return 0; 205 default: 206 return -ENOIOCTLCMD; 207 } 208 } 209 210 static const struct rtc_class_ops alpha_rtc_ops = { 211 .read_time = alpha_rtc_read_time, 212 .set_time = alpha_rtc_set_time, 213 .set_mmss64 = alpha_rtc_set_mmss, 214 .ioctl = alpha_rtc_ioctl, 215 }; 216 217 /* 218 * Similarly, except do the actual CMOS access on the boot cpu only. 219 * This requires marshalling the data across an interprocessor call. 220 */ 221 222 #if defined(CONFIG_SMP) && \ 223 (defined(CONFIG_ALPHA_GENERIC) || defined(CONFIG_ALPHA_MARVEL)) 224 # define HAVE_REMOTE_RTC 1 225 226 union remote_data { 227 struct rtc_time *tm; 228 unsigned long now; 229 long retval; 230 }; 231 232 static void 233 do_remote_read(void *data) 234 { 235 union remote_data *x = data; 236 x->retval = alpha_rtc_read_time(NULL, x->tm); 237 } 238 239 static int 240 remote_read_time(struct device *dev, struct rtc_time *tm) 241 { 242 union remote_data x; 243 if (smp_processor_id() != boot_cpuid) { 244 x.tm = tm; 245 smp_call_function_single(boot_cpuid, do_remote_read, &x, 1); 246 return x.retval; 247 } 248 return alpha_rtc_read_time(NULL, tm); 249 } 250 251 static void 252 do_remote_set(void *data) 253 { 254 union remote_data *x = data; 255 x->retval = alpha_rtc_set_time(NULL, x->tm); 256 } 257 258 static int 259 remote_set_time(struct device *dev, struct rtc_time *tm) 260 { 261 union remote_data x; 262 if (smp_processor_id() != boot_cpuid) { 263 x.tm = tm; 264 smp_call_function_single(boot_cpuid, do_remote_set, &x, 1); 265 return x.retval; 266 } 267 return alpha_rtc_set_time(NULL, tm); 268 } 269 270 static void 271 do_remote_mmss(void *data) 272 { 273 union remote_data *x = data; 274 x->retval = alpha_rtc_set_mmss(NULL, x->now); 275 } 276 277 static int 278 remote_set_mmss(struct device *dev, time64_t now) 279 { 280 union remote_data x; 281 if (smp_processor_id() != boot_cpuid) { 282 x.now = now; 283 smp_call_function_single(boot_cpuid, do_remote_mmss, &x, 1); 284 return x.retval; 285 } 286 return alpha_rtc_set_mmss(NULL, now); 287 } 288 289 static const struct rtc_class_ops remote_rtc_ops = { 290 .read_time = remote_read_time, 291 .set_time = remote_set_time, 292 .set_mmss64 = remote_set_mmss, 293 .ioctl = alpha_rtc_ioctl, 294 }; 295 #endif 296 297 static int __init 298 alpha_rtc_init(void) 299 { 300 const struct rtc_class_ops *ops; 301 struct platform_device *pdev; 302 struct rtc_device *rtc; 303 const char *name; 304 305 init_rtc_epoch(); 306 name = "rtc-alpha"; 307 ops = &alpha_rtc_ops; 308 309 #ifdef HAVE_REMOTE_RTC 310 if (alpha_mv.rtc_boot_cpu_only) 311 ops = &remote_rtc_ops; 312 #endif 313 314 pdev = platform_device_register_simple(name, -1, NULL, 0); 315 rtc = devm_rtc_device_register(&pdev->dev, name, ops, THIS_MODULE); 316 if (IS_ERR(rtc)) 317 return PTR_ERR(rtc); 318 319 platform_set_drvdata(pdev, rtc); 320 return 0; 321 } 322 device_initcall(alpha_rtc_init); 323