1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* |
3 | * Generic RTC interface. |
4 | * This version contains the part of the user interface to the Real Time Clock |
5 | * service. It is used with both the legacy mc146818 and also EFI |
6 | * Struct rtc_time and first 12 ioctl by Paul Gortmaker, 1996 - separated out |
7 | * from <linux/mc146818rtc.h> to this file for 2.4 kernels. |
8 | * |
9 | * Copyright (C) 1999 Hewlett-Packard Co. |
10 | * Copyright (C) 1999 Stephane Eranian <eranian@hpl.hp.com> |
11 | */ |
12 | #ifndef _LINUX_RTC_H_ |
13 | #define _LINUX_RTC_H_ |
14 | |
15 | |
16 | #include <linux/types.h> |
17 | #include <linux/interrupt.h> |
18 | #include <linux/nvmem-provider.h> |
19 | #include <uapi/linux/rtc.h> |
20 | |
21 | extern int rtc_month_days(unsigned int month, unsigned int year); |
22 | extern int rtc_year_days(unsigned int day, unsigned int month, unsigned int year); |
23 | extern int rtc_valid_tm(struct rtc_time *tm); |
24 | extern time64_t rtc_tm_to_time64(struct rtc_time *tm); |
25 | extern void rtc_time64_to_tm(time64_t time, struct rtc_time *tm); |
26 | ktime_t rtc_tm_to_ktime(struct rtc_time tm); |
27 | struct rtc_time rtc_ktime_to_tm(ktime_t kt); |
28 | |
29 | /* |
30 | * rtc_tm_sub - Return the difference in seconds. |
31 | */ |
32 | static inline time64_t rtc_tm_sub(struct rtc_time *lhs, struct rtc_time *rhs) |
33 | { |
34 | return rtc_tm_to_time64(tm: lhs) - rtc_tm_to_time64(tm: rhs); |
35 | } |
36 | |
37 | #include <linux/device.h> |
38 | #include <linux/seq_file.h> |
39 | #include <linux/cdev.h> |
40 | #include <linux/poll.h> |
41 | #include <linux/mutex.h> |
42 | #include <linux/timerqueue.h> |
43 | #include <linux/workqueue.h> |
44 | |
45 | extern struct class *rtc_class; |
46 | |
47 | /* |
48 | * For these RTC methods the device parameter is the physical device |
49 | * on whatever bus holds the hardware (I2C, Platform, SPI, etc), which |
50 | * was passed to rtc_device_register(). Its driver_data normally holds |
51 | * device state, including the rtc_device pointer for the RTC. |
52 | * |
53 | * Most of these methods are called with rtc_device.ops_lock held, |
54 | * through the rtc_*(struct rtc_device *, ...) calls. |
55 | * |
56 | * The (current) exceptions are mostly filesystem hooks: |
57 | * - the proc() hook for procfs |
58 | */ |
59 | struct rtc_class_ops { |
60 | int (*ioctl)(struct device *, unsigned int, unsigned long); |
61 | int (*read_time)(struct device *, struct rtc_time *); |
62 | int (*set_time)(struct device *, struct rtc_time *); |
63 | int (*read_alarm)(struct device *, struct rtc_wkalrm *); |
64 | int (*set_alarm)(struct device *, struct rtc_wkalrm *); |
65 | int (*proc)(struct device *, struct seq_file *); |
66 | int (*alarm_irq_enable)(struct device *, unsigned int enabled); |
67 | int (*read_offset)(struct device *, long *offset); |
68 | int (*set_offset)(struct device *, long offset); |
69 | int (*param_get)(struct device *, struct rtc_param *param); |
70 | int (*param_set)(struct device *, struct rtc_param *param); |
71 | }; |
72 | |
73 | struct rtc_device; |
74 | |
75 | struct rtc_timer { |
76 | struct timerqueue_node node; |
77 | ktime_t period; |
78 | void (*func)(struct rtc_device *rtc); |
79 | struct rtc_device *rtc; |
80 | int enabled; |
81 | }; |
82 | |
83 | /* flags */ |
84 | #define RTC_DEV_BUSY 0 |
85 | #define RTC_NO_CDEV 1 |
86 | |
87 | struct rtc_device { |
88 | struct device dev; |
89 | struct module *owner; |
90 | |
91 | int id; |
92 | |
93 | const struct rtc_class_ops *ops; |
94 | struct mutex ops_lock; |
95 | |
96 | struct cdev char_dev; |
97 | unsigned long flags; |
98 | |
99 | unsigned long irq_data; |
100 | spinlock_t irq_lock; |
101 | wait_queue_head_t irq_queue; |
102 | struct fasync_struct *async_queue; |
103 | |
104 | int irq_freq; |
105 | int max_user_freq; |
106 | |
107 | struct timerqueue_head timerqueue; |
108 | struct rtc_timer aie_timer; |
109 | struct rtc_timer uie_rtctimer; |
110 | struct hrtimer pie_timer; /* sub second exp, so needs hrtimer */ |
111 | int pie_enabled; |
112 | struct work_struct irqwork; |
113 | |
114 | /* |
115 | * This offset specifies the update timing of the RTC. |
116 | * |
117 | * tsched t1 write(t2.tv_sec - 1sec)) t2 RTC increments seconds |
118 | * |
119 | * The offset defines how tsched is computed so that the write to |
120 | * the RTC (t2.tv_sec - 1sec) is correct versus the time required |
121 | * for the transport of the write and the time which the RTC needs |
122 | * to increment seconds the first time after the write (t2). |
123 | * |
124 | * For direct accessible RTCs tsched ~= t1 because the write time |
125 | * is negligible. For RTCs behind slow busses the transport time is |
126 | * significant and has to be taken into account. |
127 | * |
128 | * The time between the write (t1) and the first increment after |
129 | * the write (t2) is RTC specific. For a MC146818 RTC it's 500ms, |
130 | * for many others it's exactly 1 second. Consult the datasheet. |
131 | * |
132 | * The value of this offset is also used to calculate the to be |
133 | * written value (t2.tv_sec - 1sec) at tsched. |
134 | * |
135 | * The default value for this is NSEC_PER_SEC + 10 msec default |
136 | * transport time. The offset can be adjusted by drivers so the |
137 | * calculation for the to be written value at tsched becomes |
138 | * correct: |
139 | * |
140 | * newval = tsched + set_offset_nsec - NSEC_PER_SEC |
141 | * and (tsched + set_offset_nsec) % NSEC_PER_SEC == 0 |
142 | */ |
143 | unsigned long set_offset_nsec; |
144 | |
145 | unsigned long features[BITS_TO_LONGS(RTC_FEATURE_CNT)]; |
146 | |
147 | time64_t range_min; |
148 | timeu64_t range_max; |
149 | timeu64_t alarm_offset_max; |
150 | time64_t start_secs; |
151 | time64_t offset_secs; |
152 | bool set_start_time; |
153 | |
154 | #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL |
155 | struct work_struct uie_task; |
156 | struct timer_list uie_timer; |
157 | /* Those fields are protected by rtc->irq_lock */ |
158 | unsigned int oldsecs; |
159 | unsigned int uie_irq_active:1; |
160 | unsigned int stop_uie_polling:1; |
161 | unsigned int uie_task_active:1; |
162 | unsigned int uie_timer_active:1; |
163 | #endif |
164 | }; |
165 | #define to_rtc_device(d) container_of(d, struct rtc_device, dev) |
166 | |
167 | #define rtc_lock(d) mutex_lock(&d->ops_lock) |
168 | #define rtc_unlock(d) mutex_unlock(&d->ops_lock) |
169 | |
170 | /* useful timestamps */ |
171 | #define RTC_TIMESTAMP_BEGIN_0000 -62167219200ULL /* 0000-01-01 00:00:00 */ |
172 | #define RTC_TIMESTAMP_BEGIN_1900 -2208988800LL /* 1900-01-01 00:00:00 */ |
173 | #define RTC_TIMESTAMP_BEGIN_2000 946684800LL /* 2000-01-01 00:00:00 */ |
174 | #define RTC_TIMESTAMP_END_2063 2966371199LL /* 2063-12-31 23:59:59 */ |
175 | #define RTC_TIMESTAMP_END_2079 3471292799LL /* 2079-12-31 23:59:59 */ |
176 | #define RTC_TIMESTAMP_END_2099 4102444799LL /* 2099-12-31 23:59:59 */ |
177 | #define RTC_TIMESTAMP_END_2199 7258118399LL /* 2199-12-31 23:59:59 */ |
178 | #define RTC_TIMESTAMP_END_9999 253402300799LL /* 9999-12-31 23:59:59 */ |
179 | |
180 | extern struct rtc_device *devm_rtc_device_register(struct device *dev, |
181 | const char *name, |
182 | const struct rtc_class_ops *ops, |
183 | struct module *owner); |
184 | struct rtc_device *devm_rtc_allocate_device(struct device *dev); |
185 | int __devm_rtc_register_device(struct module *owner, struct rtc_device *rtc); |
186 | |
187 | extern int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm); |
188 | extern int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm); |
189 | int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm); |
190 | extern int rtc_read_alarm(struct rtc_device *rtc, |
191 | struct rtc_wkalrm *alrm); |
192 | extern int rtc_set_alarm(struct rtc_device *rtc, |
193 | struct rtc_wkalrm *alrm); |
194 | extern int rtc_initialize_alarm(struct rtc_device *rtc, |
195 | struct rtc_wkalrm *alrm); |
196 | extern void rtc_update_irq(struct rtc_device *rtc, |
197 | unsigned long num, unsigned long events); |
198 | |
199 | extern struct rtc_device *rtc_class_open(const char *name); |
200 | extern void rtc_class_close(struct rtc_device *rtc); |
201 | |
202 | extern int rtc_irq_set_state(struct rtc_device *rtc, int enabled); |
203 | extern int rtc_irq_set_freq(struct rtc_device *rtc, int freq); |
204 | extern int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled); |
205 | extern int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled); |
206 | extern int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc, |
207 | unsigned int enabled); |
208 | |
209 | void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode); |
210 | void rtc_aie_update_irq(struct rtc_device *rtc); |
211 | void rtc_uie_update_irq(struct rtc_device *rtc); |
212 | enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer); |
213 | |
214 | void rtc_timer_init(struct rtc_timer *timer, void (*f)(struct rtc_device *r), |
215 | struct rtc_device *rtc); |
216 | int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer, |
217 | ktime_t expires, ktime_t period); |
218 | void rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer); |
219 | int rtc_read_offset(struct rtc_device *rtc, long *offset); |
220 | int rtc_set_offset(struct rtc_device *rtc, long offset); |
221 | void rtc_timer_do_work(struct work_struct *work); |
222 | |
223 | static inline bool is_leap_year(unsigned int year) |
224 | { |
225 | return (!(year % 4) && (year % 100)) || !(year % 400); |
226 | } |
227 | |
228 | /** |
229 | * rtc_bound_alarmtime() - Return alarm time bound by rtc limit |
230 | * @rtc: Pointer to rtc device structure |
231 | * @requested: Requested alarm timeout |
232 | * |
233 | * Return: Alarm timeout bound by maximum alarm time supported by rtc. |
234 | */ |
235 | static inline ktime_t rtc_bound_alarmtime(struct rtc_device *rtc, |
236 | ktime_t requested) |
237 | { |
238 | if (rtc->alarm_offset_max && |
239 | rtc->alarm_offset_max * MSEC_PER_SEC < ktime_to_ms(kt: requested)) |
240 | return ms_to_ktime(ms: rtc->alarm_offset_max * MSEC_PER_SEC); |
241 | |
242 | return requested; |
243 | } |
244 | |
245 | #define devm_rtc_register_device(device) \ |
246 | __devm_rtc_register_device(THIS_MODULE, device) |
247 | |
248 | #ifdef CONFIG_RTC_HCTOSYS_DEVICE |
249 | extern int rtc_hctosys_ret; |
250 | #else |
251 | #define rtc_hctosys_ret -ENODEV |
252 | #endif |
253 | |
254 | #ifdef CONFIG_RTC_NVMEM |
255 | int devm_rtc_nvmem_register(struct rtc_device *rtc, |
256 | struct nvmem_config *nvmem_config); |
257 | #else |
258 | static inline int devm_rtc_nvmem_register(struct rtc_device *rtc, |
259 | struct nvmem_config *nvmem_config) |
260 | { |
261 | return 0; |
262 | } |
263 | #endif |
264 | |
265 | #ifdef CONFIG_RTC_INTF_SYSFS |
266 | int rtc_add_group(struct rtc_device *rtc, const struct attribute_group *grp); |
267 | int rtc_add_groups(struct rtc_device *rtc, const struct attribute_group **grps); |
268 | #else |
269 | static inline |
270 | int rtc_add_group(struct rtc_device *rtc, const struct attribute_group *grp) |
271 | { |
272 | return 0; |
273 | } |
274 | |
275 | static inline |
276 | int rtc_add_groups(struct rtc_device *rtc, const struct attribute_group **grps) |
277 | { |
278 | return 0; |
279 | } |
280 | #endif |
281 | #endif /* _LINUX_RTC_H_ */ |
282 | |