arch/alpha/kernel/rtc.c

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