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