1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * PCM timer handling on ctxfi |
4 | */ |
5 | |
6 | #include <linux/slab.h> |
7 | #include <linux/math64.h> |
8 | #include <linux/moduleparam.h> |
9 | #include <sound/core.h> |
10 | #include <sound/pcm.h> |
11 | #include "ctatc.h" |
12 | #include "cthardware.h" |
13 | #include "cttimer.h" |
14 | |
15 | static bool use_system_timer; |
16 | MODULE_PARM_DESC(use_system_timer, "Force to use system-timer" ); |
17 | module_param(use_system_timer, bool, 0444); |
18 | |
19 | struct ct_timer_ops { |
20 | void (*init)(struct ct_timer_instance *); |
21 | void (*prepare)(struct ct_timer_instance *); |
22 | void (*start)(struct ct_timer_instance *); |
23 | void (*stop)(struct ct_timer_instance *); |
24 | void (*free_instance)(struct ct_timer_instance *); |
25 | void (*interrupt)(struct ct_timer *); |
26 | void (*free_global)(struct ct_timer *); |
27 | }; |
28 | |
29 | /* timer instance -- assigned to each PCM stream */ |
30 | struct ct_timer_instance { |
31 | spinlock_t lock; |
32 | struct ct_timer *timer_base; |
33 | struct ct_atc_pcm *apcm; |
34 | struct snd_pcm_substream *substream; |
35 | struct timer_list timer; |
36 | struct list_head instance_list; |
37 | struct list_head running_list; |
38 | unsigned int position; |
39 | unsigned int frag_count; |
40 | unsigned int running:1; |
41 | unsigned int need_update:1; |
42 | }; |
43 | |
44 | /* timer instance manager */ |
45 | struct ct_timer { |
46 | spinlock_t lock; /* global timer lock (for xfitimer) */ |
47 | spinlock_t list_lock; /* lock for instance list */ |
48 | struct ct_atc *atc; |
49 | const struct ct_timer_ops *ops; |
50 | struct list_head instance_head; |
51 | struct list_head running_head; |
52 | unsigned int wc; /* current wallclock */ |
53 | unsigned int irq_handling:1; /* in IRQ handling */ |
54 | unsigned int reprogram:1; /* need to reprogram the internval */ |
55 | unsigned int running:1; /* global timer running */ |
56 | }; |
57 | |
58 | |
59 | /* |
60 | * system-timer-based updates |
61 | */ |
62 | |
63 | static void ct_systimer_callback(struct timer_list *t) |
64 | { |
65 | struct ct_timer_instance *ti = from_timer(ti, t, timer); |
66 | struct snd_pcm_substream *substream = ti->substream; |
67 | struct snd_pcm_runtime *runtime = substream->runtime; |
68 | struct ct_atc_pcm *apcm = ti->apcm; |
69 | unsigned int period_size = runtime->period_size; |
70 | unsigned int buffer_size = runtime->buffer_size; |
71 | unsigned long flags; |
72 | unsigned int position, dist, interval; |
73 | |
74 | position = substream->ops->pointer(substream); |
75 | dist = (position + buffer_size - ti->position) % buffer_size; |
76 | if (dist >= period_size || |
77 | position / period_size != ti->position / period_size) { |
78 | apcm->interrupt(apcm); |
79 | ti->position = position; |
80 | } |
81 | /* Add extra HZ*5/1000 to avoid overrun issue when recording |
82 | * at 8kHz in 8-bit format or at 88kHz in 24-bit format. */ |
83 | interval = ((period_size - (position % period_size)) |
84 | * HZ + (runtime->rate - 1)) / runtime->rate + HZ * 5 / 1000; |
85 | spin_lock_irqsave(&ti->lock, flags); |
86 | if (ti->running) |
87 | mod_timer(timer: &ti->timer, expires: jiffies + interval); |
88 | spin_unlock_irqrestore(lock: &ti->lock, flags); |
89 | } |
90 | |
91 | static void ct_systimer_init(struct ct_timer_instance *ti) |
92 | { |
93 | timer_setup(&ti->timer, ct_systimer_callback, 0); |
94 | } |
95 | |
96 | static void ct_systimer_start(struct ct_timer_instance *ti) |
97 | { |
98 | struct snd_pcm_runtime *runtime = ti->substream->runtime; |
99 | unsigned long flags; |
100 | |
101 | spin_lock_irqsave(&ti->lock, flags); |
102 | ti->running = 1; |
103 | mod_timer(timer: &ti->timer, |
104 | expires: jiffies + (runtime->period_size * HZ + |
105 | (runtime->rate - 1)) / runtime->rate); |
106 | spin_unlock_irqrestore(lock: &ti->lock, flags); |
107 | } |
108 | |
109 | static void ct_systimer_stop(struct ct_timer_instance *ti) |
110 | { |
111 | unsigned long flags; |
112 | |
113 | spin_lock_irqsave(&ti->lock, flags); |
114 | ti->running = 0; |
115 | del_timer(timer: &ti->timer); |
116 | spin_unlock_irqrestore(lock: &ti->lock, flags); |
117 | } |
118 | |
119 | static void ct_systimer_prepare(struct ct_timer_instance *ti) |
120 | { |
121 | ct_systimer_stop(ti); |
122 | try_to_del_timer_sync(timer: &ti->timer); |
123 | } |
124 | |
125 | #define ct_systimer_free ct_systimer_prepare |
126 | |
127 | static const struct ct_timer_ops ct_systimer_ops = { |
128 | .init = ct_systimer_init, |
129 | .free_instance = ct_systimer_free, |
130 | .prepare = ct_systimer_prepare, |
131 | .start = ct_systimer_start, |
132 | .stop = ct_systimer_stop, |
133 | }; |
134 | |
135 | |
136 | /* |
137 | * Handling multiple streams using a global emu20k1 timer irq |
138 | */ |
139 | |
140 | #define CT_TIMER_FREQ 48000 |
141 | #define MIN_TICKS 1 |
142 | #define MAX_TICKS ((1 << 13) - 1) |
143 | |
144 | static void ct_xfitimer_irq_rearm(struct ct_timer *atimer, int ticks) |
145 | { |
146 | struct hw *hw = atimer->atc->hw; |
147 | if (ticks > MAX_TICKS) |
148 | ticks = MAX_TICKS; |
149 | hw->set_timer_tick(hw, ticks); |
150 | if (!atimer->running) |
151 | hw->set_timer_irq(hw, 1); |
152 | atimer->running = 1; |
153 | } |
154 | |
155 | static void ct_xfitimer_irq_stop(struct ct_timer *atimer) |
156 | { |
157 | if (atimer->running) { |
158 | struct hw *hw = atimer->atc->hw; |
159 | hw->set_timer_irq(hw, 0); |
160 | hw->set_timer_tick(hw, 0); |
161 | atimer->running = 0; |
162 | } |
163 | } |
164 | |
165 | static inline unsigned int ct_xfitimer_get_wc(struct ct_timer *atimer) |
166 | { |
167 | struct hw *hw = atimer->atc->hw; |
168 | return hw->get_wc(hw); |
169 | } |
170 | |
171 | /* |
172 | * reprogram the timer interval; |
173 | * checks the running instance list and determines the next timer interval. |
174 | * also updates the each stream position, returns the number of streams |
175 | * to call snd_pcm_period_elapsed() appropriately |
176 | * |
177 | * call this inside the lock and irq disabled |
178 | */ |
179 | static int ct_xfitimer_reprogram(struct ct_timer *atimer, int can_update) |
180 | { |
181 | struct ct_timer_instance *ti; |
182 | unsigned int min_intr = (unsigned int)-1; |
183 | int updates = 0; |
184 | unsigned int wc, diff; |
185 | |
186 | if (list_empty(head: &atimer->running_head)) { |
187 | ct_xfitimer_irq_stop(atimer); |
188 | atimer->reprogram = 0; /* clear flag */ |
189 | return 0; |
190 | } |
191 | |
192 | wc = ct_xfitimer_get_wc(atimer); |
193 | diff = wc - atimer->wc; |
194 | atimer->wc = wc; |
195 | list_for_each_entry(ti, &atimer->running_head, running_list) { |
196 | if (ti->frag_count > diff) |
197 | ti->frag_count -= diff; |
198 | else { |
199 | unsigned int pos; |
200 | unsigned int period_size, rate; |
201 | |
202 | period_size = ti->substream->runtime->period_size; |
203 | rate = ti->substream->runtime->rate; |
204 | pos = ti->substream->ops->pointer(ti->substream); |
205 | if (pos / period_size != ti->position / period_size) { |
206 | ti->need_update = 1; |
207 | ti->position = pos; |
208 | updates++; |
209 | } |
210 | pos %= period_size; |
211 | pos = period_size - pos; |
212 | ti->frag_count = div_u64(dividend: (u64)pos * CT_TIMER_FREQ + |
213 | rate - 1, divisor: rate); |
214 | } |
215 | if (ti->need_update && !can_update) |
216 | min_intr = 0; /* pending to the next irq */ |
217 | if (ti->frag_count < min_intr) |
218 | min_intr = ti->frag_count; |
219 | } |
220 | |
221 | if (min_intr < MIN_TICKS) |
222 | min_intr = MIN_TICKS; |
223 | ct_xfitimer_irq_rearm(atimer, ticks: min_intr); |
224 | atimer->reprogram = 0; /* clear flag */ |
225 | return updates; |
226 | } |
227 | |
228 | /* look through the instance list and call period_elapsed if needed */ |
229 | static void ct_xfitimer_check_period(struct ct_timer *atimer) |
230 | { |
231 | struct ct_timer_instance *ti; |
232 | unsigned long flags; |
233 | |
234 | spin_lock_irqsave(&atimer->list_lock, flags); |
235 | list_for_each_entry(ti, &atimer->instance_head, instance_list) { |
236 | if (ti->running && ti->need_update) { |
237 | ti->need_update = 0; |
238 | ti->apcm->interrupt(ti->apcm); |
239 | } |
240 | } |
241 | spin_unlock_irqrestore(lock: &atimer->list_lock, flags); |
242 | } |
243 | |
244 | /* Handle timer-interrupt */ |
245 | static void ct_xfitimer_callback(struct ct_timer *atimer) |
246 | { |
247 | int update; |
248 | unsigned long flags; |
249 | |
250 | spin_lock_irqsave(&atimer->lock, flags); |
251 | atimer->irq_handling = 1; |
252 | do { |
253 | update = ct_xfitimer_reprogram(atimer, can_update: 1); |
254 | spin_unlock(lock: &atimer->lock); |
255 | if (update) |
256 | ct_xfitimer_check_period(atimer); |
257 | spin_lock(lock: &atimer->lock); |
258 | } while (atimer->reprogram); |
259 | atimer->irq_handling = 0; |
260 | spin_unlock_irqrestore(lock: &atimer->lock, flags); |
261 | } |
262 | |
263 | static void ct_xfitimer_prepare(struct ct_timer_instance *ti) |
264 | { |
265 | ti->frag_count = ti->substream->runtime->period_size; |
266 | ti->running = 0; |
267 | ti->need_update = 0; |
268 | } |
269 | |
270 | |
271 | /* start/stop the timer */ |
272 | static void ct_xfitimer_update(struct ct_timer *atimer) |
273 | { |
274 | unsigned long flags; |
275 | |
276 | spin_lock_irqsave(&atimer->lock, flags); |
277 | if (atimer->irq_handling) { |
278 | /* reached from IRQ handler; let it handle later */ |
279 | atimer->reprogram = 1; |
280 | spin_unlock_irqrestore(lock: &atimer->lock, flags); |
281 | return; |
282 | } |
283 | |
284 | ct_xfitimer_irq_stop(atimer); |
285 | ct_xfitimer_reprogram(atimer, can_update: 0); |
286 | spin_unlock_irqrestore(lock: &atimer->lock, flags); |
287 | } |
288 | |
289 | static void ct_xfitimer_start(struct ct_timer_instance *ti) |
290 | { |
291 | struct ct_timer *atimer = ti->timer_base; |
292 | unsigned long flags; |
293 | |
294 | spin_lock_irqsave(&atimer->lock, flags); |
295 | if (list_empty(head: &ti->running_list)) |
296 | atimer->wc = ct_xfitimer_get_wc(atimer); |
297 | ti->running = 1; |
298 | ti->need_update = 0; |
299 | list_add(new: &ti->running_list, head: &atimer->running_head); |
300 | spin_unlock_irqrestore(lock: &atimer->lock, flags); |
301 | ct_xfitimer_update(atimer); |
302 | } |
303 | |
304 | static void ct_xfitimer_stop(struct ct_timer_instance *ti) |
305 | { |
306 | struct ct_timer *atimer = ti->timer_base; |
307 | unsigned long flags; |
308 | |
309 | spin_lock_irqsave(&atimer->lock, flags); |
310 | list_del_init(entry: &ti->running_list); |
311 | ti->running = 0; |
312 | spin_unlock_irqrestore(lock: &atimer->lock, flags); |
313 | ct_xfitimer_update(atimer); |
314 | } |
315 | |
316 | static void ct_xfitimer_free_global(struct ct_timer *atimer) |
317 | { |
318 | ct_xfitimer_irq_stop(atimer); |
319 | } |
320 | |
321 | static const struct ct_timer_ops ct_xfitimer_ops = { |
322 | .prepare = ct_xfitimer_prepare, |
323 | .start = ct_xfitimer_start, |
324 | .stop = ct_xfitimer_stop, |
325 | .interrupt = ct_xfitimer_callback, |
326 | .free_global = ct_xfitimer_free_global, |
327 | }; |
328 | |
329 | /* |
330 | * timer instance |
331 | */ |
332 | |
333 | struct ct_timer_instance * |
334 | ct_timer_instance_new(struct ct_timer *atimer, struct ct_atc_pcm *apcm) |
335 | { |
336 | struct ct_timer_instance *ti; |
337 | |
338 | ti = kzalloc(size: sizeof(*ti), GFP_KERNEL); |
339 | if (!ti) |
340 | return NULL; |
341 | spin_lock_init(&ti->lock); |
342 | INIT_LIST_HEAD(list: &ti->instance_list); |
343 | INIT_LIST_HEAD(list: &ti->running_list); |
344 | ti->timer_base = atimer; |
345 | ti->apcm = apcm; |
346 | ti->substream = apcm->substream; |
347 | if (atimer->ops->init) |
348 | atimer->ops->init(ti); |
349 | |
350 | spin_lock_irq(lock: &atimer->list_lock); |
351 | list_add(new: &ti->instance_list, head: &atimer->instance_head); |
352 | spin_unlock_irq(lock: &atimer->list_lock); |
353 | |
354 | return ti; |
355 | } |
356 | |
357 | void ct_timer_prepare(struct ct_timer_instance *ti) |
358 | { |
359 | if (ti->timer_base->ops->prepare) |
360 | ti->timer_base->ops->prepare(ti); |
361 | ti->position = 0; |
362 | ti->running = 0; |
363 | } |
364 | |
365 | void ct_timer_start(struct ct_timer_instance *ti) |
366 | { |
367 | struct ct_timer *atimer = ti->timer_base; |
368 | atimer->ops->start(ti); |
369 | } |
370 | |
371 | void ct_timer_stop(struct ct_timer_instance *ti) |
372 | { |
373 | struct ct_timer *atimer = ti->timer_base; |
374 | atimer->ops->stop(ti); |
375 | } |
376 | |
377 | void ct_timer_instance_free(struct ct_timer_instance *ti) |
378 | { |
379 | struct ct_timer *atimer = ti->timer_base; |
380 | |
381 | atimer->ops->stop(ti); /* to be sure */ |
382 | if (atimer->ops->free_instance) |
383 | atimer->ops->free_instance(ti); |
384 | |
385 | spin_lock_irq(lock: &atimer->list_lock); |
386 | list_del(entry: &ti->instance_list); |
387 | spin_unlock_irq(lock: &atimer->list_lock); |
388 | |
389 | kfree(objp: ti); |
390 | } |
391 | |
392 | /* |
393 | * timer manager |
394 | */ |
395 | |
396 | static void ct_timer_interrupt(void *data, unsigned int status) |
397 | { |
398 | struct ct_timer *timer = data; |
399 | |
400 | /* Interval timer interrupt */ |
401 | if ((status & IT_INT) && timer->ops->interrupt) |
402 | timer->ops->interrupt(timer); |
403 | } |
404 | |
405 | struct ct_timer *ct_timer_new(struct ct_atc *atc) |
406 | { |
407 | struct ct_timer *atimer; |
408 | struct hw *hw; |
409 | |
410 | atimer = kzalloc(size: sizeof(*atimer), GFP_KERNEL); |
411 | if (!atimer) |
412 | return NULL; |
413 | spin_lock_init(&atimer->lock); |
414 | spin_lock_init(&atimer->list_lock); |
415 | INIT_LIST_HEAD(list: &atimer->instance_head); |
416 | INIT_LIST_HEAD(list: &atimer->running_head); |
417 | atimer->atc = atc; |
418 | hw = atc->hw; |
419 | if (!use_system_timer && hw->set_timer_irq) { |
420 | dev_info(atc->card->dev, "Use xfi-native timer\n" ); |
421 | atimer->ops = &ct_xfitimer_ops; |
422 | hw->irq_callback_data = atimer; |
423 | hw->irq_callback = ct_timer_interrupt; |
424 | } else { |
425 | dev_info(atc->card->dev, "Use system timer\n" ); |
426 | atimer->ops = &ct_systimer_ops; |
427 | } |
428 | return atimer; |
429 | } |
430 | |
431 | void ct_timer_free(struct ct_timer *atimer) |
432 | { |
433 | struct hw *hw = atimer->atc->hw; |
434 | hw->irq_callback = NULL; |
435 | if (atimer->ops->free_global) |
436 | atimer->ops->free_global(atimer); |
437 | kfree(objp: atimer); |
438 | } |
439 | |
440 | |