1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright 2008 by Andreas Eversberg <andreas@eversberg.eu> |
4 | * |
5 | * Quick API description: |
6 | * |
7 | * A clock source registers using mISDN_register_clock: |
8 | * name = text string to name clock source |
9 | * priority = value to priorize clock sources (0 = default) |
10 | * ctl = callback function to enable/disable clock source |
11 | * priv = private pointer of clock source |
12 | * return = pointer to clock source structure; |
13 | * |
14 | * Note: Callback 'ctl' can be called before mISDN_register_clock returns! |
15 | * Also it can be called during mISDN_unregister_clock. |
16 | * |
17 | * A clock source calls mISDN_clock_update with given samples elapsed, if |
18 | * enabled. If function call is delayed, tv must be set with the timestamp |
19 | * of the actual event. |
20 | * |
21 | * A clock source unregisters using mISDN_unregister_clock. |
22 | * |
23 | * To get current clock, call mISDN_clock_get. The signed short value |
24 | * counts the number of samples since. Time since last clock event is added. |
25 | */ |
26 | |
27 | #include <linux/slab.h> |
28 | #include <linux/types.h> |
29 | #include <linux/stddef.h> |
30 | #include <linux/spinlock.h> |
31 | #include <linux/ktime.h> |
32 | #include <linux/mISDNif.h> |
33 | #include <linux/export.h> |
34 | #include "core.h" |
35 | |
36 | static u_int *debug; |
37 | static LIST_HEAD(iclock_list); |
38 | static DEFINE_RWLOCK(iclock_lock); |
39 | static u16 iclock_count; /* counter of last clock */ |
40 | static ktime_t iclock_timestamp; /* time stamp of last clock */ |
41 | static int iclock_timestamp_valid; /* already received one timestamp */ |
42 | static struct mISDNclock *iclock_current; |
43 | |
44 | void |
45 | mISDN_init_clock(u_int *dp) |
46 | { |
47 | debug = dp; |
48 | iclock_timestamp = ktime_get(); |
49 | } |
50 | |
51 | static void |
52 | select_iclock(void) |
53 | { |
54 | struct mISDNclock *iclock, *bestclock = NULL, *lastclock = NULL; |
55 | int pri = -128; |
56 | |
57 | list_for_each_entry(iclock, &iclock_list, list) { |
58 | if (iclock->pri > pri) { |
59 | pri = iclock->pri; |
60 | bestclock = iclock; |
61 | } |
62 | if (iclock_current == iclock) |
63 | lastclock = iclock; |
64 | } |
65 | if (lastclock && bestclock != lastclock) { |
66 | /* last used clock source still exists but changes, disable */ |
67 | if (*debug & DEBUG_CLOCK) |
68 | printk(KERN_DEBUG "Old clock source '%s' disable.\n" , |
69 | lastclock->name); |
70 | lastclock->ctl(lastclock->priv, 0); |
71 | } |
72 | if (bestclock && bestclock != iclock_current) { |
73 | /* new clock source selected, enable */ |
74 | if (*debug & DEBUG_CLOCK) |
75 | printk(KERN_DEBUG "New clock source '%s' enable.\n" , |
76 | bestclock->name); |
77 | bestclock->ctl(bestclock->priv, 1); |
78 | } |
79 | if (bestclock != iclock_current) { |
80 | /* no clock received yet */ |
81 | iclock_timestamp_valid = 0; |
82 | } |
83 | iclock_current = bestclock; |
84 | } |
85 | |
86 | struct mISDNclock |
87 | *mISDN_register_clock(char *name, int pri, clockctl_func_t *ctl, void *priv) |
88 | { |
89 | u_long flags; |
90 | struct mISDNclock *iclock; |
91 | |
92 | if (*debug & (DEBUG_CORE | DEBUG_CLOCK)) |
93 | printk(KERN_DEBUG "%s: %s %d\n" , __func__, name, pri); |
94 | iclock = kzalloc(size: sizeof(struct mISDNclock), GFP_ATOMIC); |
95 | if (!iclock) { |
96 | printk(KERN_ERR "%s: No memory for clock entry.\n" , __func__); |
97 | return NULL; |
98 | } |
99 | strscpy(iclock->name, name, sizeof(iclock->name)); |
100 | iclock->pri = pri; |
101 | iclock->priv = priv; |
102 | iclock->ctl = ctl; |
103 | write_lock_irqsave(&iclock_lock, flags); |
104 | list_add_tail(new: &iclock->list, head: &iclock_list); |
105 | select_iclock(); |
106 | write_unlock_irqrestore(&iclock_lock, flags); |
107 | return iclock; |
108 | } |
109 | EXPORT_SYMBOL(mISDN_register_clock); |
110 | |
111 | void |
112 | mISDN_unregister_clock(struct mISDNclock *iclock) |
113 | { |
114 | u_long flags; |
115 | |
116 | if (*debug & (DEBUG_CORE | DEBUG_CLOCK)) |
117 | printk(KERN_DEBUG "%s: %s %d\n" , __func__, iclock->name, |
118 | iclock->pri); |
119 | write_lock_irqsave(&iclock_lock, flags); |
120 | if (iclock_current == iclock) { |
121 | if (*debug & DEBUG_CLOCK) |
122 | printk(KERN_DEBUG |
123 | "Current clock source '%s' unregisters.\n" , |
124 | iclock->name); |
125 | iclock->ctl(iclock->priv, 0); |
126 | } |
127 | list_del(entry: &iclock->list); |
128 | select_iclock(); |
129 | write_unlock_irqrestore(&iclock_lock, flags); |
130 | } |
131 | EXPORT_SYMBOL(mISDN_unregister_clock); |
132 | |
133 | void |
134 | mISDN_clock_update(struct mISDNclock *iclock, int samples, ktime_t *timestamp) |
135 | { |
136 | u_long flags; |
137 | ktime_t timestamp_now; |
138 | u16 delta; |
139 | |
140 | write_lock_irqsave(&iclock_lock, flags); |
141 | if (iclock_current != iclock) { |
142 | printk(KERN_ERR "%s: '%s' sends us clock updates, but we do " |
143 | "listen to '%s'. This is a bug!\n" , __func__, |
144 | iclock->name, |
145 | iclock_current ? iclock_current->name : "nothing" ); |
146 | iclock->ctl(iclock->priv, 0); |
147 | write_unlock_irqrestore(&iclock_lock, flags); |
148 | return; |
149 | } |
150 | if (iclock_timestamp_valid) { |
151 | /* increment sample counter by given samples */ |
152 | iclock_count += samples; |
153 | if (timestamp) { /* timestamp must be set, if function call is delayed */ |
154 | iclock_timestamp = *timestamp; |
155 | } else { |
156 | iclock_timestamp = ktime_get(); |
157 | } |
158 | } else { |
159 | /* calc elapsed time by system clock */ |
160 | if (timestamp) { /* timestamp must be set, if function call is delayed */ |
161 | timestamp_now = *timestamp; |
162 | } else { |
163 | timestamp_now = ktime_get(); |
164 | } |
165 | delta = ktime_divns(ktime_sub(timestamp_now, iclock_timestamp), |
166 | div: (NSEC_PER_SEC / 8000)); |
167 | /* add elapsed time to counter and set new timestamp */ |
168 | iclock_count += delta; |
169 | iclock_timestamp = timestamp_now; |
170 | iclock_timestamp_valid = 1; |
171 | if (*debug & DEBUG_CLOCK) |
172 | printk("Received first clock from source '%s'.\n" , |
173 | iclock_current ? iclock_current->name : "nothing" ); |
174 | } |
175 | write_unlock_irqrestore(&iclock_lock, flags); |
176 | } |
177 | EXPORT_SYMBOL(mISDN_clock_update); |
178 | |
179 | unsigned short |
180 | mISDN_clock_get(void) |
181 | { |
182 | u_long flags; |
183 | ktime_t timestamp_now; |
184 | u16 delta; |
185 | u16 count; |
186 | |
187 | read_lock_irqsave(&iclock_lock, flags); |
188 | /* calc elapsed time by system clock */ |
189 | timestamp_now = ktime_get(); |
190 | delta = ktime_divns(ktime_sub(timestamp_now, iclock_timestamp), |
191 | div: (NSEC_PER_SEC / 8000)); |
192 | /* add elapsed time to counter */ |
193 | count = iclock_count + delta; |
194 | read_unlock_irqrestore(&iclock_lock, flags); |
195 | return count; |
196 | } |
197 | EXPORT_SYMBOL(mISDN_clock_get); |
198 | |