include/rtc.h

   1 /*
   2  * (C) Copyright 2001
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 /*
   9  * Generic RTC interface.
  10  */
  11 #ifndef _RTC_H_
  12 #define _RTC_H_
  13
  14 /* bcd<->bin functions are needed by almost all the RTC drivers, let's include
  15  * it there instead of in evey single driver */
  16
  17 #include <bcd.h>
  18 #include <rtc_def.h>
  19
  20 #ifdef CONFIG_DM_RTC
  21
  22 struct rtc_ops {
  23         /**
  24          * get() - get the current time
  25          *
  26          * Returns the current time read from the RTC device. The driver
  27          * is responsible for setting up every field in the structure.
  28          *
  29          * @dev:        Device to read from
  30          * @time:       Place to put the time that is read
  31          */
  32         int (*get)(struct udevice *dev, struct rtc_time *time);
  33
  34         /**
  35          * set() - set the current time
  36          *
  37          * Sets the time in the RTC device. The driver can expect every
  38          * field to be set correctly.
  39          *
  40          * @dev:        Device to read from
  41          * @time:       Time to write
  42          */
  43         int (*set)(struct udevice *dev, const struct rtc_time *time);
  44
  45         /**
  46          * reset() - reset the RTC to a known-good state
  47          *
  48          * This function resets the RTC to a known-good state. The time may
  49          * be unset by this method, so should be set after this method is
  50          * called.
  51          *
  52          * @dev:        Device to read from
  53          * @return 0 if OK, -ve on error
  54          */
  55         int (*reset)(struct udevice *dev);
  56
  57         /**
  58          * read8() - Read an 8-bit register
  59          *
  60          * @dev:        Device to read from
  61          * @reg:        Register to read
  62          * @return value read, or -ve on error
  63          */
  64         int (*read8)(struct udevice *dev, unsigned int reg);
  65
  66         /**
  67         * write8() - Write an 8-bit register
  68         *
  69         * @dev:         Device to write to
  70         * @reg:         Register to write
  71         * @value:       Value to write
  72         * @return 0 if OK, -ve on error
  73         */
  74         int (*write8)(struct udevice *dev, unsigned int reg, int val);
  75 };
  76
  77 /* Access the operations for an RTC device */
  78 #define rtc_get_ops(dev)        ((struct rtc_ops *)(dev)->driver->ops)
  79
  80 /**
  81  * dm_rtc_get() - Read the time from an RTC
  82  *
  83  * @dev:        Device to read from
  84  * @time:       Place to put the current time
  85  * @return 0 if OK, -ve on error
  86  */
  87 int dm_rtc_get(struct udevice *dev, struct rtc_time *time);
  88
  89 /**
  90  * dm_rtc_put() - Write a time to an RTC
  91  *
  92  * @dev:        Device to read from
  93  * @time:       Time to write into the RTC
  94  * @return 0 if OK, -ve on error
  95  */
  96 int dm_rtc_set(struct udevice *dev, struct rtc_time *time);
  97
  98 /**
  99  * dm_rtc_reset() - reset the RTC to a known-good state
 100  *
 101  * If the RTC appears to be broken (e.g. it is not counting up in seconds)
 102  * it may need to be reset to a known good state. This function achieves this.
 103  * After resetting the RTC the time should then be set to a known value by
 104  * the caller.
 105  *
 106  * @dev:        Device to read from
 107  * @return 0 if OK, -ve on error
 108  */
 109 int dm_rtc_reset(struct udevice *dev);
 110
 111 /**
 112  * rtc_read8() - Read an 8-bit register
 113  *
 114  * @dev:        Device to read from
 115  * @reg:        Register to read
 116  * @return value read, or -ve on error
 117  */
 118 int rtc_read8(struct udevice *dev, unsigned int reg);
 119
 120 /**
 121  * rtc_write8() - Write an 8-bit register
 122  *
 123  * @dev:        Device to write to
 124  * @reg:        Register to write
 125  * @value:      Value to write
 126  * @return 0 if OK, -ve on error
 127  */
 128 int rtc_write8(struct udevice *dev, unsigned int reg, int val);
 129
 130 /**
 131  * rtc_read32() - Read a 32-bit value from the RTC
 132  *
 133  * @dev:        Device to read from
 134  * @reg:        Offset to start reading from
 135  * @valuep:     Place to put the value that is read
 136  * @return 0 if OK, -ve on error
 137  */
 138 int rtc_read32(struct udevice *dev, unsigned int reg, u32 *valuep);
 139
 140 /**
 141  * rtc_write32() - Write a 32-bit value to the RTC
 142  *
 143  * @dev:        Device to write to
 144  * @reg:        Register to start writing to
 145  * @value:      Value to write
 146  * @return 0 if OK, -ve on error
 147  */
 148 int rtc_write32(struct udevice *dev, unsigned int reg, u32 value);
 149
 150 #else
 151 int rtc_get (struct rtc_time *);
 152 int rtc_set (struct rtc_time *);
 153 void rtc_reset (void);
 154 void rtc_enable_32khz_output(void);
 155
 156 /**
 157  * rtc_read8() - Read an 8-bit register
 158  *
 159  * @reg:        Register to read
 160  * @return value read
 161  */
 162 int rtc_read8(int reg);
 163
 164 /**
 165  * rtc_write8() - Write an 8-bit register
 166  *
 167  * @reg:        Register to write
 168  * @value:      Value to write
 169  */
 170 void rtc_write8(int reg, uchar val);
 171
 172 /**
 173  * rtc_read32() - Read a 32-bit value from the RTC
 174  *
 175  * @reg:        Offset to start reading from
 176  * @return value read
 177  */
 178 u32 rtc_read32(int reg);
 179
 180 /**
 181  * rtc_write32() - Write a 32-bit value to the RTC
 182  *
 183  * @reg:        Register to start writing to
 184  * @value:      Value to write
 185  */
 186 void rtc_write32(int reg, u32 value);
 187
 188 /**
 189  * rtc_init() - Set up the real time clock ready for use
 190  */
 191 void rtc_init(void);
 192 #endif
 193
 194 /**
 195  * rtc_calc_weekday() - Work out the weekday from a time
 196  *
 197  * This only works for the Gregorian calendar - i.e. after 1752 (in the UK).
 198  * It sets time->tm_wdaay to the correct day of the week.
 199  *
 200  * @time:       Time to inspect. tm_wday is updated
 201  * @return 0 if OK, -EINVAL if the weekday could not be determined
 202  */
 203 int rtc_calc_weekday(struct rtc_time *time);
 204
 205 /**
 206  * rtc_to_tm() - Convert a time_t value into a broken-out time
 207  *
 208  * The following fields are set up by this function:
 209  *      tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year, tm_wday
 210  *
 211  * Note that tm_yday and tm_isdst are set to 0.
 212  *
 213  * @time_t:     Number of seconds since 1970-01-01 00:00:00
 214  * @time:       Place to put the broken-out time
 215  * @return 0 if OK, -EINVAL if the weekday could not be determined
 216  */
 217 int rtc_to_tm(int time_t, struct rtc_time *time);
 218
 219 /**
 220  * rtc_mktime() - Convert a broken-out time into a time_t value
 221  *
 222  * The following fields need to be valid for this function to work:
 223  *      tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year
 224  *
 225  * Note that tm_wday and tm_yday are ignored.
 226  *
 227  * @time:       Broken-out time to convert
 228  * @return corresponding time_t value, seconds since 1970-01-01 00:00:00
 229  */
 230 unsigned long rtc_mktime(const struct rtc_time *time);
 231
 232 #endif  /* _RTC_H_ */