arch/sh/kernel/cpu/rtc.c

   1 /*
   2  * linux/arch/sh/kernel/rtc.c -- SH3 / SH4 on-chip RTC support
   3  *
   4  *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
   5  *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
   6  */
   7
   8 #include <linux/init.h>
   9 #include <linux/kernel.h>
  10 #include <linux/sched.h>
  11 #include <linux/time.h>
  12
  13 #include <asm/io.h>
  14 #include <asm/rtc.h>
  15
  16 #ifndef BCD_TO_BIN
  17 #define BCD_TO_BIN(val) ((val)=((val)&15) + ((val)>>4)*10)
  18 #endif
  19
  20 #ifndef BIN_TO_BCD
  21 #define BIN_TO_BCD(val) ((val)=(((val)/10)<<4) + (val)%10)
  22 #endif
  23
  24 void sh_rtc_gettimeofday(struct timespec *ts)
  25 {
  26         unsigned int sec128, sec, min, hr, wk, day, mon, yr, yr100;
  27
  28  again:
  29         do {
  30                 ctrl_outb(0, RCR1);  /* Clear CF-bit */
  31                 sec128 = ctrl_inb(R64CNT);
  32                 sec = ctrl_inb(RSECCNT);
  33                 min = ctrl_inb(RMINCNT);
  34                 hr  = ctrl_inb(RHRCNT);
  35                 wk  = ctrl_inb(RWKCNT);
  36                 day = ctrl_inb(RDAYCNT);
  37                 mon = ctrl_inb(RMONCNT);
  38 #if defined(CONFIG_CPU_SH4)
  39                 yr  = ctrl_inw(RYRCNT);
  40                 yr100 = (yr >> 8);
  41                 yr &= 0xff;
  42 #else
  43                 yr  = ctrl_inb(RYRCNT);
  44                 yr100 = (yr == 0x99) ? 0x19 : 0x20;
  45 #endif
  46         } while ((ctrl_inb(RCR1) & RCR1_CF) != 0);
  47
  48 #if RTC_BIT_INVERTED != 0
  49         /* Work around to avoid reading incorrect value. */
  50         if (sec128 == RTC_BIT_INVERTED) {
  51                 schedule_timeout(1);
  52                 goto again;
  53         }
  54 #endif
  55
  56         BCD_TO_BIN(yr100);
  57         BCD_TO_BIN(yr);
  58         BCD_TO_BIN(mon);
  59         BCD_TO_BIN(day);
  60         BCD_TO_BIN(hr);
  61         BCD_TO_BIN(min);
  62         BCD_TO_BIN(sec);
  63
  64         if (yr > 99 || mon < 1 || mon > 12 || day > 31 || day < 1 ||
  65             hr > 23 || min > 59 || sec > 59) {
  66                 printk(KERN_ERR
  67                        "SH RTC: invalid value, resetting to 1 Jan 2000\n");
  68                 ctrl_outb(RCR2_RESET, RCR2);  /* Reset & Stop */
  69                 ctrl_outb(0, RSECCNT);
  70                 ctrl_outb(0, RMINCNT);
  71                 ctrl_outb(0, RHRCNT);
  72                 ctrl_outb(6, RWKCNT);
  73                 ctrl_outb(1, RDAYCNT);
  74                 ctrl_outb(1, RMONCNT);
  75 #if defined(CONFIG_CPU_SH4)
  76                 ctrl_outw(0x2000, RYRCNT);
  77 #else
  78                 ctrl_outb(0, RYRCNT);
  79 #endif
  80                 ctrl_outb(RCR2_RTCEN|RCR2_START, RCR2);  /* Start */
  81                 goto again;
  82         }
  83
  84 #if RTC_BIT_INVERTED != 0
  85         if ((sec128 & RTC_BIT_INVERTED))
  86                 sec--;
  87 #endif
  88
  89         ts->tv_sec = mktime(yr100 * 100 + yr, mon, day, hr, min, sec);
  90         ts->tv_nsec = ((sec128 * 1000000) / 128) * 1000;
  91 }
  92
  93 /*
  94  * Changed to only care about tv_sec, and not the full timespec struct
  95  * (i.e. tv_nsec).  It can easily be switched to timespec for future cpus
  96  * that support setting usec or nsec RTC values.
  97  */
  98 int sh_rtc_settimeofday(const time_t secs)
  99 {
 100         int retval = 0;
 101         int real_seconds, real_minutes, cmos_minutes;
 102
 103         ctrl_outb(RCR2_RESET, RCR2);  /* Reset pre-scaler & stop RTC */
 104
 105         cmos_minutes = ctrl_inb(RMINCNT);
 106         BCD_TO_BIN(cmos_minutes);
 107
 108         /*
 109          * since we're only adjusting minutes and seconds,
 110          * don't interfere with hour overflow. This avoids
 111          * messing with unknown time zones but requires your
 112          * RTC not to be off by more than 15 minutes
 113          */
 114         real_seconds = secs % 60;
 115         real_minutes = secs / 60;
 116         if (((abs(real_minutes - cmos_minutes) + 15)/30) & 1)
 117                 real_minutes += 30;     /* correct for half hour time zone */
 118         real_minutes %= 60;
 119
 120         if (abs(real_minutes - cmos_minutes) < 30) {
 121                 BIN_TO_BCD(real_seconds);
 122                 BIN_TO_BCD(real_minutes);
 123                 ctrl_outb(real_seconds, RSECCNT);
 124                 ctrl_outb(real_minutes, RMINCNT);
 125         } else {
 126                 printk(KERN_WARNING
 127                        "set_rtc_time: can't update from %d to %d\n",
 128                        cmos_minutes, real_minutes);
 129                 retval = -1;
 130         }
 131
 132         ctrl_outb(RCR2_RTCEN|RCR2_START, RCR2);  /* Start RTC */
 133
 134         return retval;
 135 }