git.sur5r.net Git - u-boot/blob - drivers/rtc/m41t60.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2007
   4  * Larry Johnson, lrj@acm.org
   5  *
   6  * based on rtc/m41t11.c which is ...
   7  *
   8  * (C) Copyright 2002
   9  * Andrew May, Viasat Inc, amay@viasat.com
  10  */
  11
  12 /*
  13  * STMicroelectronics M41T60 serial access real-time clock
  14  */
  15
  16 /* #define DEBUG 1 */
  17
  18 #include <common.h>
  19 #include <command.h>
  20 #include <rtc.h>
  21 #include <i2c.h>
  22
  23 #if defined(CONFIG_SYS_I2C_RTC_ADDR) && defined(CONFIG_CMD_DATE)
  24
  25 /*
  26  * Convert between century and "century bits" (CB1 and CB0).  These routines
  27  * assume years are in the range 1900 - 2299.
  28  */
  29
  30 static unsigned char year2cb(unsigned const year)
  31 {
  32         if (year < 1900 || year >= 2300)
  33                 printf("M41T60 RTC: year %d out of range\n", year);
  34
  35         return (year / 100) & 0x3;
  36 }
  37
  38 static unsigned cb2year(unsigned const cb)
  39 {
  40         return 1900 + 100 * ((cb + 1) & 0x3);
  41 }
  42
  43 /*
  44  * These are simple defines for the chip local to here so they aren't too
  45  * verbose.  DAY/DATE aren't nice but that is how they are on the data sheet.
  46  */
  47 #define RTC_SEC         0x0
  48 #define RTC_MIN         0x1
  49 #define RTC_HOUR        0x2
  50 #define RTC_DAY         0x3
  51 #define RTC_DATE        0x4
  52 #define RTC_MONTH       0x5
  53 #define RTC_YEAR        0x6
  54
  55 #define RTC_REG_CNT     7
  56
  57 #define RTC_CTRL        0x7
  58
  59 #if defined(DEBUG)
  60 static void rtc_dump(char const *const label)
  61 {
  62         uchar data[8];
  63
  64         if (i2c_read(CONFIG_SYS_I2C_RTC_ADDR, 0, 1, data, sizeof(data))) {
  65                 printf("I2C read failed in rtc_dump()\n");
  66                 return;
  67         }
  68         printf("RTC dump %s: %02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
  69                label, data[0], data[1], data[2], data[3],
  70                data[4], data[5], data[6], data[7]);
  71 }
  72 #else
  73 #define rtc_dump(label)
  74 #endif
  75
  76 static uchar *rtc_validate(void)
  77 {
  78         /*
  79          * This routine uses the OUT bit and the validity of the time values to
  80          * determine whether there has been an initial power-up since the last
  81          * time the routine was run.  It assumes that the OUT bit is not being
  82          * used for any other purpose.
  83          */
  84         static const uchar daysInMonth[0x13] = {
  85                 0x00, 0x31, 0x29, 0x31, 0x30, 0x31, 0x30, 0x31,
  86                 0x31, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  87                 0x31, 0x30, 0x31
  88         };
  89         static uchar data[8];
  90         uchar min, date, month, years;
  91
  92         rtc_dump("begin validate");
  93         if (i2c_read(CONFIG_SYS_I2C_RTC_ADDR, 0, 1, data, sizeof(data))) {
  94                 printf("I2C read failed in rtc_validate()\n");
  95                 return 0;
  96         }
  97         /*
  98          * If the OUT bit is "1", there has been a loss of power, so stop the
  99          * oscillator so it can be "kick-started" as per data sheet.
 100          */
 101         if (0x00 != (data[RTC_CTRL] & 0x80)) {
 102                 printf("M41T60 RTC clock lost power.\n");
 103                 data[RTC_SEC] = 0x80;
 104                 if (i2c_write(CONFIG_SYS_I2C_RTC_ADDR, RTC_SEC, 1, data, 1)) {
 105                         printf("I2C write failed in rtc_validate()\n");
 106                         return 0;
 107                 }
 108         }
 109         /*
 110          * If the oscillator is stopped or the date is invalid, then reset the
 111          * OUT bit to "0", reset the date registers, and start the oscillator.
 112          */
 113         min = data[RTC_MIN] & 0x7F;
 114         date = data[RTC_DATE];
 115         month = data[RTC_MONTH] & 0x3F;
 116         years = data[RTC_YEAR];
 117         if (0x59 < data[RTC_SEC] || 0x09 < (data[RTC_SEC] & 0x0F) ||
 118             0x59 < min || 0x09 < (min & 0x0F) ||
 119             0x23 < data[RTC_HOUR] || 0x09 < (data[RTC_HOUR] & 0x0F) ||
 120             0x07 < data[RTC_DAY] || 0x00 == data[RTC_DAY] ||
 121             0x12 < month ||
 122             0x99 < years || 0x09 < (years & 0x0F) ||
 123             daysInMonth[month] < date || 0x09 < (date & 0x0F) || 0x00 == date ||
 124             (0x29 == date && 0x02 == month &&
 125              ((0x00 != (years & 0x03)) ||
 126               (0x00 == years && 0x00 != (data[RTC_MONTH] & 0xC0))))) {
 127                 printf("Resetting M41T60 RTC clock.\n");
 128                 /*
 129                  * Set to 00:00:00 1900-01-01 (Monday)
 130                  */
 131                 data[RTC_SEC] = 0x00;
 132                 data[RTC_MIN] &= 0x80;  /* preserve OFIE bit */
 133                 data[RTC_HOUR] = 0x00;
 134                 data[RTC_DAY] = 0x02;
 135                 data[RTC_DATE] = 0x01;
 136                 data[RTC_MONTH] = 0xC1;
 137                 data[RTC_YEAR] = 0x00;
 138                 data[RTC_CTRL] &= 0x7F; /* reset OUT bit */
 139
 140                 if (i2c_write(CONFIG_SYS_I2C_RTC_ADDR, 0, 1, data, sizeof(data))) {
 141                         printf("I2C write failed in rtc_validate()\n");
 142                         return 0;
 143                 }
 144         }
 145         return data;
 146 }
 147
 148 int rtc_get(struct rtc_time *tmp)
 149 {
 150         uchar const *const data = rtc_validate();
 151
 152         if (!data)
 153                 return -1;
 154
 155         tmp->tm_sec = bcd2bin(data[RTC_SEC] & 0x7F);
 156         tmp->tm_min = bcd2bin(data[RTC_MIN] & 0x7F);
 157         tmp->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3F);
 158         tmp->tm_mday = bcd2bin(data[RTC_DATE] & 0x3F);
 159         tmp->tm_mon = bcd2bin(data[RTC_MONTH] & 0x1F);
 160         tmp->tm_year = cb2year(data[RTC_MONTH] >> 6) + bcd2bin(data[RTC_YEAR]);
 161         tmp->tm_wday = bcd2bin(data[RTC_DAY] & 0x07) - 1;
 162         tmp->tm_yday = 0;
 163         tmp->tm_isdst = 0;
 164
 165         debug("Get DATE: %4d-%02d-%02d (wday=%d)  TIME: %2d:%02d:%02d\n",
 166               tmp->tm_year, tmp->tm_mon, tmp->tm_mday, tmp->tm_wday,
 167               tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
 168
 169         return 0;
 170 }
 171
 172 int rtc_set(struct rtc_time *tmp)
 173 {
 174         uchar *const data = rtc_validate();
 175
 176         if (!data)
 177                 return -1;
 178
 179         debug("Set DATE: %4d-%02d-%02d (wday=%d)  TIME: %2d:%02d:%02d\n",
 180               tmp->tm_year, tmp->tm_mon, tmp->tm_mday, tmp->tm_wday,
 181               tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
 182
 183         data[RTC_SEC] = (data[RTC_SEC] & 0x80) | (bin2bcd(tmp->tm_sec) & 0x7F);
 184         data[RTC_MIN] = (data[RTC_MIN] & 0X80) | (bin2bcd(tmp->tm_min) & 0X7F);
 185         data[RTC_HOUR] = bin2bcd(tmp->tm_hour) & 0x3F;
 186         data[RTC_DATE] = bin2bcd(tmp->tm_mday) & 0x3F;
 187         data[RTC_MONTH] = bin2bcd(tmp->tm_mon) & 0x1F;
 188         data[RTC_YEAR] = bin2bcd(tmp->tm_year % 100);
 189         data[RTC_MONTH] |= year2cb(tmp->tm_year) << 6;
 190         data[RTC_DAY] = bin2bcd(tmp->tm_wday + 1) & 0x07;
 191         if (i2c_write(CONFIG_SYS_I2C_RTC_ADDR, 0, 1, data, RTC_REG_CNT)) {
 192                 printf("I2C write failed in rtc_set()\n");
 193                 return -1;
 194         }
 195
 196         return 0;
 197 }
 198
 199 void rtc_reset(void)
 200 {
 201         uchar *const data = rtc_validate();
 202         char const *const s = env_get("rtccal");
 203
 204         if (!data)
 205                 return;
 206
 207         rtc_dump("begin reset");
 208         /*
 209          * If environmental variable "rtccal" is present, it must be a hex value
 210          * between 0x00 and 0x3F, inclusive.  The five least-significan bits
 211          * represent the calibration magnitude, and the sixth bit the sign bit.
 212          * If these do not match the contents of the hardware register, that
 213          * register is updated.  The value 0x00 imples no correction.  Consult
 214          * the M41T60 documentation for further details.
 215          */
 216         if (s) {
 217                 unsigned long const l = simple_strtoul(s, 0, 16);
 218
 219                 if (l <= 0x3F) {
 220                         if ((data[RTC_CTRL] & 0x3F) != l) {
 221                                 printf("Setting RTC calibration to 0x%02lX\n",
 222                                        l);
 223                                 data[RTC_CTRL] &= 0xC0;
 224                                 data[RTC_CTRL] |= (uchar) l;
 225                         }
 226                 } else
 227                         printf("environment parameter \"rtccal\" not valid: "
 228                                "ignoring\n");
 229         }
 230         /*
 231          * Turn off frequency test.
 232          */
 233         data[RTC_CTRL] &= 0xBF;
 234         if (i2c_write(CONFIG_SYS_I2C_RTC_ADDR, RTC_CTRL, 1, data + RTC_CTRL, 1)) {
 235                 printf("I2C write failed in rtc_reset()\n");
 236                 return;
 237         }
 238         rtc_dump("end reset");
 239 }
 240 #endif /* CONFIG_RTC_M41T60 && CONFIG_SYS_I2C_RTC_ADDR && CONFIG_CMD_DATE */