~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/ctxfi/cttimer.c

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 18 static bool use_system_timer;
 19 MODULE_PARM_DESC(use_system_timer, "Force to use system-timer");
 20 module_param(use_system_timer, bool, S_IRUGO);
 21 
 22 struct 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 */
 33 struct 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 */
 48 struct 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 
 66 static 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 
 94 static void ct_systimer_init(struct ct_timer_instance *ti)
 95 {
 96         setup_timer(&ti->timer, ct_systimer_callback,
 97                     (unsigned long)ti);
 98 }
 99 
100 static 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 
113 static 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 
123 static 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 
131 static 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 
148 static 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 
159 static 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 
169 static 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  */
183 static 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 */
233 static 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 */
249 static 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 
267 static 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 */
276 static 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 
293 static 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 
308 static 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 
320 static void ct_xfitimer_free_global(struct ct_timer *atimer)
321 {
322         ct_xfitimer_irq_stop(atimer);
323 }
324 
325 static 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 
337 struct ct_timer_instance *
338 ct_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 
361 void 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 
369 void ct_timer_start(struct ct_timer_instance *ti)
370 {
371         struct ct_timer *atimer = ti->timer_base;
372         atimer->ops->start(ti);
373 }
374 
375 void ct_timer_stop(struct ct_timer_instance *ti)
376 {
377         struct ct_timer *atimer = ti->timer_base;
378         atimer->ops->stop(ti);
379 }
380 
381 void 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 
400 static 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 
409 struct 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                 snd_printd(KERN_INFO "ctxfi: 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                 snd_printd(KERN_INFO "ctxfi: Use system timer\n");
430                 atimer->ops = &ct_systimer_ops;
431         }
432         return atimer;
433 }
434 
435 void 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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp