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_read16() - Read a 16-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_read16(struct udevice *dev, unsigned int reg, u16 *valuep);
 139
 140 /**
 141  * rtc_write16() - Write a 16-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_write16(struct udevice *dev, unsigned int reg, u16 value);
 149
 150 /**
 151  * rtc_read32() - Read a 32-bit value from the RTC
 152  *
 153  * @dev:        Device to read from
 154  * @reg:        Offset to start reading from
 155  * @valuep:     Place to put the value that is read
 156  * @return 0 if OK, -ve on error
 157  */
 158 int rtc_read32(struct udevice *dev, unsigned int reg, u32 *valuep);
 159
 160 /**
 161  * rtc_write32() - Write a 32-bit value to the RTC
 162  *
 163  * @dev:        Device to write to
 164  * @reg:        Register to start writing to
 165  * @value:      Value to write
 166  * @return 0 if OK, -ve on error
 167  */
 168 int rtc_write32(struct udevice *dev, unsigned int reg, u32 value);
 169
 170 #else
 171 int rtc_get (struct rtc_time *);
 172 int rtc_set (struct rtc_time *);
 173 void rtc_reset (void);
 174 void rtc_enable_32khz_output(void);
 175
 176 /**
 177  * rtc_read8() - Read an 8-bit register
 178  *
 179  * @reg:        Register to read
 180  * @return value read
 181  */
 182 int rtc_read8(int reg);
 183
 184 /**
 185  * rtc_write8() - Write an 8-bit register
 186  *
 187  * @reg:        Register to write
 188  * @value:      Value to write
 189  */
 190 void rtc_write8(int reg, uchar val);
 191
 192 /**
 193  * rtc_read32() - Read a 32-bit value from the RTC
 194  *
 195  * @reg:        Offset to start reading from
 196  * @return value read
 197  */
 198 u32 rtc_read32(int reg);
 199
 200 /**
 201  * rtc_write32() - Write a 32-bit value to the RTC
 202  *
 203  * @reg:        Register to start writing to
 204  * @value:      Value to write
 205  */
 206 void rtc_write32(int reg, u32 value);
 207
 208 /**
 209  * rtc_init() - Set up the real time clock ready for use
 210  */
 211 void rtc_init(void);
 212 #endif
 213
 214 /**
 215  * rtc_calc_weekday() - Work out the weekday from a time
 216  *
 217  * This only works for the Gregorian calendar - i.e. after 1752 (in the UK).
 218  * It sets time->tm_wdaay to the correct day of the week.
 219  *
 220  * @time:       Time to inspect. tm_wday is updated
 221  * @return 0 if OK, -EINVAL if the weekday could not be determined
 222  */
 223 int rtc_calc_weekday(struct rtc_time *time);
 224
 225 /**
 226  * rtc_to_tm() - Convert a time_t value into a broken-out time
 227  *
 228  * The following fields are set up by this function:
 229  *      tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year, tm_wday
 230  *
 231  * Note that tm_yday and tm_isdst are set to 0.
 232  *
 233  * @time_t:     Number of seconds since 1970-01-01 00:00:00
 234  * @time:       Place to put the broken-out time
 235  * @return 0 if OK, -EINVAL if the weekday could not be determined
 236  */
 237 int rtc_to_tm(int time_t, struct rtc_time *time);
 238
 239 /**
 240  * rtc_mktime() - Convert a broken-out time into a time_t value
 241  *
 242  * The following fields need to be valid for this function to work:
 243  *      tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year
 244  *
 245  * Note that tm_wday and tm_yday are ignored.
 246  *
 247  * @time:       Broken-out time to convert
 248  * @return corresponding time_t value, seconds since 1970-01-01 00:00:00
 249  */
 250 unsigned long rtc_mktime(const struct rtc_time *time);
 251
 252 #endif  /* _RTC_H_ */