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(lhs) - rtc_tm_to_time64(rhs); |
35 | } |
36 | |
37 | static inline void rtc_time_to_tm(unsigned long time, struct rtc_time *tm) |
38 | { |
39 | rtc_time64_to_tm(time, tm); |
40 | } |
41 | |
42 | static inline int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time) |
43 | { |
44 | *time = rtc_tm_to_time64(tm); |
45 | |
46 | return 0; |
47 | } |
48 | |
49 | #include <linux/device.h> |
50 | #include <linux/seq_file.h> |
51 | #include <linux/cdev.h> |
52 | #include <linux/poll.h> |
53 | #include <linux/mutex.h> |
54 | #include <linux/timerqueue.h> |
55 | #include <linux/workqueue.h> |
56 | |
57 | extern struct class *rtc_class; |
58 | |
59 | /* |
60 | * For these RTC methods the device parameter is the physical device |
61 | * on whatever bus holds the hardware (I2C, Platform, SPI, etc), which |
62 | * was passed to rtc_device_register(). Its driver_data normally holds |
63 | * device state, including the rtc_device pointer for the RTC. |
64 | * |
65 | * Most of these methods are called with rtc_device.ops_lock held, |
66 | * through the rtc_*(struct rtc_device *, ...) calls. |
67 | * |
68 | * The (current) exceptions are mostly filesystem hooks: |
69 | * - the proc() hook for procfs |
70 | * - non-ioctl() chardev hooks: open(), release() |
71 | * |
72 | * REVISIT those periodic irq calls *do* have ops_lock when they're |
73 | * issued through ioctl() ... |
74 | */ |
75 | struct rtc_class_ops { |
76 | int (*ioctl)(struct device *, unsigned int, unsigned long); |
77 | int (*read_time)(struct device *, struct rtc_time *); |
78 | int (*set_time)(struct device *, struct rtc_time *); |
79 | int (*read_alarm)(struct device *, struct rtc_wkalrm *); |
80 | int (*set_alarm)(struct device *, struct rtc_wkalrm *); |
81 | int (*proc)(struct device *, struct seq_file *); |
82 | int (*set_mmss64)(struct device *, time64_t secs); |
83 | int (*set_mmss)(struct device *, unsigned long secs); |
84 | int (*alarm_irq_enable)(struct device *, unsigned int enabled); |
85 | int (*read_offset)(struct device *, long *offset); |
86 | int (*set_offset)(struct device *, long offset); |
87 | }; |
88 | |
89 | struct rtc_device; |
90 | |
91 | struct rtc_timer { |
92 | struct timerqueue_node node; |
93 | ktime_t period; |
94 | void (*func)(struct rtc_device *rtc); |
95 | struct rtc_device *rtc; |
96 | int enabled; |
97 | }; |
98 | |
99 | /* flags */ |
100 | #define RTC_DEV_BUSY 0 |
101 | |
102 | struct rtc_device { |
103 | struct device dev; |
104 | struct module *owner; |
105 | |
106 | int id; |
107 | |
108 | const struct rtc_class_ops *ops; |
109 | struct mutex ops_lock; |
110 | |
111 | struct cdev char_dev; |
112 | unsigned long flags; |
113 | |
114 | unsigned long irq_data; |
115 | spinlock_t irq_lock; |
116 | wait_queue_head_t irq_queue; |
117 | struct fasync_struct *async_queue; |
118 | |
119 | int irq_freq; |
120 | int max_user_freq; |
121 | |
122 | struct timerqueue_head timerqueue; |
123 | struct rtc_timer aie_timer; |
124 | struct rtc_timer uie_rtctimer; |
125 | struct hrtimer pie_timer; /* sub second exp, so needs hrtimer */ |
126 | int pie_enabled; |
127 | struct work_struct irqwork; |
128 | /* Some hardware can't support UIE mode */ |
129 | int uie_unsupported; |
130 | |
131 | /* Number of nsec it takes to set the RTC clock. This influences when |
132 | * the set ops are called. An offset: |
133 | * - of 0.5 s will call RTC set for wall clock time 10.0 s at 9.5 s |
134 | * - of 1.5 s will call RTC set for wall clock time 10.0 s at 8.5 s |
135 | * - of -0.5 s will call RTC set for wall clock time 10.0 s at 10.5 s |
136 | */ |
137 | long set_offset_nsec; |
138 | |
139 | bool registered; |
140 | |
141 | /* Old ABI support */ |
142 | bool nvram_old_abi; |
143 | struct bin_attribute *nvram; |
144 | |
145 | time64_t range_min; |
146 | timeu64_t range_max; |
147 | time64_t start_secs; |
148 | time64_t offset_secs; |
149 | bool set_start_time; |
150 | |
151 | #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL |
152 | struct work_struct uie_task; |
153 | struct timer_list uie_timer; |
154 | /* Those fields are protected by rtc->irq_lock */ |
155 | unsigned int oldsecs; |
156 | unsigned int uie_irq_active:1; |
157 | unsigned int stop_uie_polling:1; |
158 | unsigned int uie_task_active:1; |
159 | unsigned int uie_timer_active:1; |
160 | #endif |
161 | }; |
162 | #define to_rtc_device(d) container_of(d, struct rtc_device, dev) |
163 | |
164 | /* useful timestamps */ |
165 | #define RTC_TIMESTAMP_BEGIN_1900 -2208989361LL /* 1900-01-01 00:00:00 */ |
166 | #define RTC_TIMESTAMP_BEGIN_2000 946684800LL /* 2000-01-01 00:00:00 */ |
167 | #define RTC_TIMESTAMP_END_2099 4102444799LL /* 2099-12-31 23:59:59 */ |
168 | |
169 | extern struct rtc_device *devm_rtc_device_register(struct device *dev, |
170 | const char *name, |
171 | const struct rtc_class_ops *ops, |
172 | struct module *owner); |
173 | struct rtc_device *devm_rtc_allocate_device(struct device *dev); |
174 | int __rtc_register_device(struct module *owner, struct rtc_device *rtc); |
175 | |
176 | extern int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm); |
177 | extern int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm); |
178 | extern int rtc_set_ntp_time(struct timespec64 now, unsigned long *target_nsec); |
179 | int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm); |
180 | extern int rtc_read_alarm(struct rtc_device *rtc, |
181 | struct rtc_wkalrm *alrm); |
182 | extern int rtc_set_alarm(struct rtc_device *rtc, |
183 | struct rtc_wkalrm *alrm); |
184 | extern int rtc_initialize_alarm(struct rtc_device *rtc, |
185 | struct rtc_wkalrm *alrm); |
186 | extern void rtc_update_irq(struct rtc_device *rtc, |
187 | unsigned long num, unsigned long events); |
188 | |
189 | extern struct rtc_device *rtc_class_open(const char *name); |
190 | extern void rtc_class_close(struct rtc_device *rtc); |
191 | |
192 | extern int rtc_irq_set_state(struct rtc_device *rtc, int enabled); |
193 | extern int rtc_irq_set_freq(struct rtc_device *rtc, int freq); |
194 | extern int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled); |
195 | extern int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled); |
196 | extern int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc, |
197 | unsigned int enabled); |
198 | |
199 | void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode); |
200 | void rtc_aie_update_irq(struct rtc_device *rtc); |
201 | void rtc_uie_update_irq(struct rtc_device *rtc); |
202 | enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer); |
203 | |
204 | void rtc_timer_init(struct rtc_timer *timer, void (*f)(struct rtc_device *r), |
205 | struct rtc_device *rtc); |
206 | int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer, |
207 | ktime_t expires, ktime_t period); |
208 | void rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer); |
209 | int rtc_read_offset(struct rtc_device *rtc, long *offset); |
210 | int rtc_set_offset(struct rtc_device *rtc, long offset); |
211 | void rtc_timer_do_work(struct work_struct *work); |
212 | |
213 | static inline bool is_leap_year(unsigned int year) |
214 | { |
215 | return (!(year % 4) && (year % 100)) || !(year % 400); |
216 | } |
217 | |
218 | /* Determine if we can call to driver to set the time. Drivers can only be |
219 | * called to set a second aligned time value, and the field set_offset_nsec |
220 | * specifies how far away from the second aligned time to call the driver. |
221 | * |
222 | * This also computes 'to_set' which is the time we are trying to set, and has |
223 | * a zero in tv_nsecs, such that: |
224 | * to_set - set_delay_nsec == now +/- FUZZ |
225 | * |
226 | */ |
227 | static inline bool rtc_tv_nsec_ok(s64 set_offset_nsec, |
228 | struct timespec64 *to_set, |
229 | const struct timespec64 *now) |
230 | { |
231 | /* Allowed error in tv_nsec, arbitarily set to 5 jiffies in ns. */ |
232 | const unsigned long TIME_SET_NSEC_FUZZ = TICK_NSEC * 5; |
233 | struct timespec64 delay = {.tv_sec = 0, |
234 | .tv_nsec = set_offset_nsec}; |
235 | |
236 | *to_set = timespec64_add(*now, delay); |
237 | |
238 | if (to_set->tv_nsec < TIME_SET_NSEC_FUZZ) { |
239 | to_set->tv_nsec = 0; |
240 | return true; |
241 | } |
242 | |
243 | if (to_set->tv_nsec > NSEC_PER_SEC - TIME_SET_NSEC_FUZZ) { |
244 | to_set->tv_sec++; |
245 | to_set->tv_nsec = 0; |
246 | return true; |
247 | } |
248 | return false; |
249 | } |
250 | |
251 | #define rtc_register_device(device) \ |
252 | __rtc_register_device(THIS_MODULE, device) |
253 | |
254 | #ifdef CONFIG_RTC_HCTOSYS_DEVICE |
255 | extern int rtc_hctosys_ret; |
256 | #else |
257 | #define rtc_hctosys_ret -ENODEV |
258 | #endif |
259 | |
260 | #ifdef CONFIG_RTC_NVMEM |
261 | int rtc_nvmem_register(struct rtc_device *rtc, |
262 | struct nvmem_config *nvmem_config); |
263 | void rtc_nvmem_unregister(struct rtc_device *rtc); |
264 | #else |
265 | static inline int rtc_nvmem_register(struct rtc_device *rtc, |
266 | struct nvmem_config *nvmem_config) |
267 | { |
268 | return 0; |
269 | } |
270 | static inline void rtc_nvmem_unregister(struct rtc_device *rtc) {} |
271 | #endif |
272 | |
273 | #ifdef CONFIG_RTC_INTF_SYSFS |
274 | int rtc_add_group(struct rtc_device *rtc, const struct attribute_group *grp); |
275 | int rtc_add_groups(struct rtc_device *rtc, const struct attribute_group **grps); |
276 | #else |
277 | static inline |
278 | int rtc_add_group(struct rtc_device *rtc, const struct attribute_group *grp) |
279 | { |
280 | return 0; |
281 | } |
282 | |
283 | static inline |
284 | int rtc_add_groups(struct rtc_device *rtc, const struct attribute_group **grps) |
285 | { |
286 | return 0; |
287 | } |
288 | #endif |
289 | #endif /* _LINUX_RTC_H_ */ |
290 | |