Merge branch 'master' of git://git.denx.de/u-boot-usb
[platform/kernel/u-boot.git] / 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_ */