arch/alpha/kernel/rtc.c

   1 /*
   2  *  linux/arch/alpha/kernel/rtc.c
   3  *
   4  *  Copyright (C) 1991, 1992, 1995, 1999, 2000  Linus Torvalds
   5  *
   6  * This file contains date handling.
   7  */
   8 #include <linux/errno.h>
   9 #include <linux/init.h>
  10 #include <linux/kernel.h>
  11 #include <linux/param.h>
  12 #include <linux/string.h>
  13 #include <linux/mc146818rtc.h>
  14 #include <linux/bcd.h>
  15 #include <linux/rtc.h>
  16 #include <linux/platform_device.h>
  17
  18 #include "proto.h"
  19
  20
  21 /*
  22  * Support for the RTC device.
  23  *
  24  * We don't want to use the rtc-cmos driver, because we don't want to support
  25  * alarms, as that would be indistinguishable from timer interrupts.
  26  *
  27  * Further, generic code is really, really tied to a 1900 epoch.  This is
  28  * true in __get_rtc_time as well as the users of struct rtc_time e.g.
  29  * rtc_tm_to_time.  Thankfully all of the other epochs in use are later
  30  * than 1900, and so it's easy to adjust.
  31  */
  32
  33 static unsigned long rtc_epoch;
  34
  35 static int __init
  36 specifiy_epoch(char *str)
  37 {
  38         unsigned long epoch = simple_strtoul(str, NULL, 0);
  39         if (epoch < 1900)
  40                 printk("Ignoring invalid user specified epoch %lu\n", epoch);
  41         else
  42                 rtc_epoch = epoch;
  43         return 1;
  44 }
  45 __setup("epoch=", specifiy_epoch);
  46
  47 static void __init
  48 init_rtc_epoch(void)
  49 {
  50         int epoch, year, ctrl;
  51
  52         if (rtc_epoch != 0) {
  53                 /* The epoch was specified on the command-line.  */
  54                 return;
  55         }
  56
  57         /* Detect the epoch in use on this computer.  */
  58         ctrl = CMOS_READ(RTC_CONTROL);
  59         year = CMOS_READ(RTC_YEAR);
  60         if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
  61                 year = bcd2bin(year);
  62
  63         /* PC-like is standard; used for year >= 70 */
  64         epoch = 1900;
  65         if (year < 20) {
  66                 epoch = 2000;
  67         } else if (year >= 20 && year < 48) {
  68                 /* NT epoch */
  69                 epoch = 1980;
  70         } else if (year >= 48 && year < 70) {
  71                 /* Digital UNIX epoch */
  72                 epoch = 1952;
  73         }
  74         rtc_epoch = epoch;
  75
  76         printk(KERN_INFO "Using epoch %d for rtc year %d\n", epoch, year);
  77 }
  78
  79 static int
  80 alpha_rtc_read_time(struct device *dev, struct rtc_time *tm)
  81 {
  82         mc146818_get_time(tm);
  83
  84         /* Adjust for non-default epochs.  It's easier to depend on the
  85            generic __get_rtc_time and adjust the epoch here than create
  86            a copy of __get_rtc_time with the edits we need.  */
  87         if (rtc_epoch != 1900) {
  88                 int year = tm->tm_year;
  89                 /* Undo the century adjustment made in __get_rtc_time.  */
  90                 if (year >= 100)
  91                         year -= 100;
  92                 year += rtc_epoch - 1900;
  93                 /* Redo the century adjustment with the epoch in place.  */
  94                 if (year <= 69)
  95                         year += 100;
  96                 tm->tm_year = year;
  97         }
  98
  99         return rtc_valid_tm(tm);
 100 }
 101
 102 static int
 103 alpha_rtc_set_time(struct device *dev, struct rtc_time *tm)
 104 {
 105         struct rtc_time xtm;
 106
 107         if (rtc_epoch != 1900) {
 108                 xtm = *tm;
 109                 xtm.tm_year -= rtc_epoch - 1900;
 110                 tm = &xtm;
 111         }
 112
 113         return mc146818_set_time(tm);
 114 }
 115
 116 static int
 117 alpha_rtc_set_mmss(struct device *dev, time64_t nowtime)
 118 {
 119         int retval = 0;
 120         int real_seconds, real_minutes, cmos_minutes;
 121         unsigned char save_control, save_freq_select;
 122
 123         /* Note: This code only updates minutes and seconds.  Comments
 124            indicate this was to avoid messing with unknown time zones,
 125            and with the epoch nonsense described above.  In order for
 126            this to work, the existing clock cannot be off by more than
 127            15 minutes.
 128
 129            ??? This choice is may be out of date.  The x86 port does
 130            not have problems with timezones, and the epoch processing has
 131            now been fixed in alpha_set_rtc_time.
 132
 133            In either case, one can always force a full rtc update with
 134            the userland hwclock program, so surely 15 minute accuracy
 135            is no real burden.  */
 136
 137         /* In order to set the CMOS clock precisely, we have to be called
 138            500 ms after the second nowtime has started, because when
 139            nowtime is written into the registers of the CMOS clock, it will
 140            jump to the next second precisely 500 ms later. Check the Motorola
 141            MC146818A or Dallas DS12887 data sheet for details.  */
 142
 143         /* irq are locally disabled here */
 144         spin_lock(&rtc_lock);
 145         /* Tell the clock it's being set */
 146         save_control = CMOS_READ(RTC_CONTROL);
 147         CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
 148
 149         /* Stop and reset prescaler */
 150         save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
 151         CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
 152
 153         cmos_minutes = CMOS_READ(RTC_MINUTES);
 154         if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
 155                 cmos_minutes = bcd2bin(cmos_minutes);
 156
 157         real_seconds = nowtime % 60;
 158         real_minutes = nowtime / 60;
 159         if (((abs(real_minutes - cmos_minutes) + 15) / 30) & 1) {
 160                 /* correct for half hour time zone */
 161                 real_minutes += 30;
 162         }
 163         real_minutes %= 60;
 164
 165         if (abs(real_minutes - cmos_minutes) < 30) {
 166                 if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
 167                         real_seconds = bin2bcd(real_seconds);
 168                         real_minutes = bin2bcd(real_minutes);
 169                 }
 170                 CMOS_WRITE(real_seconds,RTC_SECONDS);
 171                 CMOS_WRITE(real_minutes,RTC_MINUTES);
 172         } else {
 173                 printk_once(KERN_NOTICE
 174                             "set_rtc_mmss: can't update from %d to %d\n",
 175                             cmos_minutes, real_minutes);
 176                 retval = -1;
 177         }
 178
 179         /* The following flags have to be released exactly in this order,
 180          * otherwise the DS12887 (popular MC146818A clone with integrated
 181          * battery and quartz) will not reset the oscillator and will not
 182          * update precisely 500 ms later. You won't find this mentioned in
 183          * the Dallas Semiconductor data sheets, but who believes data
 184          * sheets anyway ...                           -- Markus Kuhn
 185          */
 186         CMOS_WRITE(save_control, RTC_CONTROL);
 187         CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
 188         spin_unlock(&rtc_lock);
 189
 190         return retval;
 191 }
 192
 193 static int
 194 alpha_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 195 {
 196         switch (cmd) {
 197         case RTC_EPOCH_READ:
 198                 return put_user(rtc_epoch, (unsigned long __user *)arg);
 199         case RTC_EPOCH_SET:
 200                 if (arg < 1900)
 201                         return -EINVAL;
 202                 rtc_epoch = arg;
 203                 return 0;
 204         default:
 205                 return -ENOIOCTLCMD;
 206         }
 207 }
 208
 209 static const struct rtc_class_ops alpha_rtc_ops = {
 210         .read_time = alpha_rtc_read_time,
 211         .set_time = alpha_rtc_set_time,
 212         .set_mmss64 = alpha_rtc_set_mmss,
 213         .ioctl = alpha_rtc_ioctl,
 214 };
 215
 216 /*
 217  * Similarly, except do the actual CMOS access on the boot cpu only.
 218  * This requires marshalling the data across an interprocessor call.
 219  */
 220
 221 #if defined(CONFIG_SMP) && \
 222     (defined(CONFIG_ALPHA_GENERIC) || defined(CONFIG_ALPHA_MARVEL))
 223 # define HAVE_REMOTE_RTC 1
 224
 225 union remote_data {
 226         struct rtc_time *tm;
 227         unsigned long now;
 228         long retval;
 229 };
 230
 231 static void
 232 do_remote_read(void *data)
 233 {
 234         union remote_data *x = data;
 235         x->retval = alpha_rtc_read_time(NULL, x->tm);
 236 }
 237
 238 static int
 239 remote_read_time(struct device *dev, struct rtc_time *tm)
 240 {
 241         union remote_data x;
 242         if (smp_processor_id() != boot_cpuid) {
 243                 x.tm = tm;
 244                 smp_call_function_single(boot_cpuid, do_remote_read, &x, 1);
 245                 return x.retval;
 246         }
 247         return alpha_rtc_read_time(NULL, tm);
 248 }
 249
 250 static void
 251 do_remote_set(void *data)
 252 {
 253         union remote_data *x = data;
 254         x->retval = alpha_rtc_set_time(NULL, x->tm);
 255 }
 256
 257 static int
 258 remote_set_time(struct device *dev, struct rtc_time *tm)
 259 {
 260         union remote_data x;
 261         if (smp_processor_id() != boot_cpuid) {
 262                 x.tm = tm;
 263                 smp_call_function_single(boot_cpuid, do_remote_set, &x, 1);
 264                 return x.retval;
 265         }
 266         return alpha_rtc_set_time(NULL, tm);
 267 }
 268
 269 static void
 270 do_remote_mmss(void *data)
 271 {
 272         union remote_data *x = data;
 273         x->retval = alpha_rtc_set_mmss(NULL, x->now);
 274 }
 275
 276 static int
 277 remote_set_mmss(struct device *dev, time64_t now)
 278 {
 279         union remote_data x;
 280         if (smp_processor_id() != boot_cpuid) {
 281                 x.now = now;
 282                 smp_call_function_single(boot_cpuid, do_remote_mmss, &x, 1);
 283                 return x.retval;
 284         }
 285         return alpha_rtc_set_mmss(NULL, now);
 286 }
 287
 288 static const struct rtc_class_ops remote_rtc_ops = {
 289         .read_time = remote_read_time,
 290         .set_time = remote_set_time,
 291         .set_mmss64 = remote_set_mmss,
 292         .ioctl = alpha_rtc_ioctl,
 293 };
 294 #endif
 295
 296 static int __init
 297 alpha_rtc_init(void)
 298 {
 299         const struct rtc_class_ops *ops;
 300         struct platform_device *pdev;
 301         struct rtc_device *rtc;
 302         const char *name;
 303
 304         init_rtc_epoch();
 305         name = "rtc-alpha";
 306         ops = &alpha_rtc_ops;
 307
 308 #ifdef HAVE_REMOTE_RTC
 309         if (alpha_mv.rtc_boot_cpu_only)
 310                 ops = &remote_rtc_ops;
 311 #endif
 312
 313         pdev = platform_device_register_simple(name, -1, NULL, 0);
 314         rtc = devm_rtc_device_register(&pdev->dev, name, ops, THIS_MODULE);
 315         if (IS_ERR(rtc))
 316                 return PTR_ERR(rtc);
 317
 318         platform_set_drvdata(pdev, rtc);
 319         return 0;
 320 }
 321 device_initcall(alpha_rtc_init);