2 * Timers abstract layer
3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <sound/driver.h>
23 #include <linux/delay.h>
24 #include <linux/init.h>
25 #include <linux/smp_lock.h>
26 #include <linux/slab.h>
27 #include <linux/time.h>
28 #include <linux/moduleparam.h>
29 #include <linux/string.h>
30 #include <sound/core.h>
31 #include <sound/timer.h>
32 #include <sound/control.h>
33 #include <sound/info.h>
34 #include <sound/minors.h>
35 #include <sound/initval.h>
36 #include <linux/kmod.h>
38 #include <linux/kerneld.h>
41 #if defined(CONFIG_SND_HPET) || defined(CONFIG_SND_HPET_MODULE)
42 #define DEFAULT_TIMER_LIMIT 3
43 #elif defined(CONFIG_SND_RTCTIMER) || defined(CONFIG_SND_RTCTIMER_MODULE)
44 #define DEFAULT_TIMER_LIMIT 2
46 #define DEFAULT_TIMER_LIMIT 1
49 static int timer_limit
= DEFAULT_TIMER_LIMIT
;
50 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Takashi Iwai <tiwai@suse.de>");
51 MODULE_DESCRIPTION("ALSA timer interface");
52 MODULE_LICENSE("GPL");
53 module_param(timer_limit
, int, 0444);
54 MODULE_PARM_DESC(timer_limit
, "Maximum global timers in system.");
56 struct snd_timer_user
{
57 struct snd_timer_instance
*timeri
;
58 int tread
; /* enhanced read with timestamps and events */
60 unsigned long overrun
;
65 struct snd_timer_read
*queue
;
66 struct snd_timer_tread
*tqueue
;
68 unsigned long last_resolution
;
70 struct timespec tstamp
; /* trigger tstamp */
71 wait_queue_head_t qchange_sleep
;
72 struct fasync_struct
*fasync
;
73 struct semaphore tread_sem
;
77 static LIST_HEAD(snd_timer_list
);
79 /* list of slave instances */
80 static LIST_HEAD(snd_timer_slave_list
);
82 /* lock for slave active lists */
83 static DEFINE_SPINLOCK(slave_active_lock
);
85 static DECLARE_MUTEX(register_mutex
);
87 static int snd_timer_free(struct snd_timer
*timer
);
88 static int snd_timer_dev_free(struct snd_device
*device
);
89 static int snd_timer_dev_register(struct snd_device
*device
);
90 static int snd_timer_dev_unregister(struct snd_device
*device
);
92 static void snd_timer_reschedule(struct snd_timer
* timer
, unsigned long ticks_left
);
95 * create a timer instance with the given owner string.
96 * when timer is not NULL, increments the module counter
98 static struct snd_timer_instance
*snd_timer_instance_new(char *owner
,
99 struct snd_timer
*timer
)
101 struct snd_timer_instance
*timeri
;
102 timeri
= kzalloc(sizeof(*timeri
), GFP_KERNEL
);
105 timeri
->owner
= kstrdup(owner
, GFP_KERNEL
);
106 if (! timeri
->owner
) {
110 INIT_LIST_HEAD(&timeri
->open_list
);
111 INIT_LIST_HEAD(&timeri
->active_list
);
112 INIT_LIST_HEAD(&timeri
->ack_list
);
113 INIT_LIST_HEAD(&timeri
->slave_list_head
);
114 INIT_LIST_HEAD(&timeri
->slave_active_head
);
116 timeri
->timer
= timer
;
117 if (timer
&& !try_module_get(timer
->module
)) {
118 kfree(timeri
->owner
);
127 * find a timer instance from the given timer id
129 static struct snd_timer
*snd_timer_find(struct snd_timer_id
*tid
)
131 struct snd_timer
*timer
= NULL
;
134 list_for_each(p
, &snd_timer_list
) {
135 timer
= list_entry(p
, struct snd_timer
, device_list
);
137 if (timer
->tmr_class
!= tid
->dev_class
)
139 if ((timer
->tmr_class
== SNDRV_TIMER_CLASS_CARD
||
140 timer
->tmr_class
== SNDRV_TIMER_CLASS_PCM
) &&
141 (timer
->card
== NULL
||
142 timer
->card
->number
!= tid
->card
))
144 if (timer
->tmr_device
!= tid
->device
)
146 if (timer
->tmr_subdevice
!= tid
->subdevice
)
155 static void snd_timer_request(struct snd_timer_id
*tid
)
157 if (! current
->fs
->root
)
159 switch (tid
->dev_class
) {
160 case SNDRV_TIMER_CLASS_GLOBAL
:
161 if (tid
->device
< timer_limit
)
162 request_module("snd-timer-%i", tid
->device
);
164 case SNDRV_TIMER_CLASS_CARD
:
165 case SNDRV_TIMER_CLASS_PCM
:
166 if (tid
->card
< snd_ecards_limit
)
167 request_module("snd-card-%i", tid
->card
);
177 * look for a master instance matching with the slave id of the given slave.
178 * when found, relink the open_link of the slave.
180 * call this with register_mutex down.
182 static void snd_timer_check_slave(struct snd_timer_instance
*slave
)
184 struct snd_timer
*timer
;
185 struct snd_timer_instance
*master
;
186 struct list_head
*p
, *q
;
188 /* FIXME: it's really dumb to look up all entries.. */
189 list_for_each(p
, &snd_timer_list
) {
190 timer
= list_entry(p
, struct snd_timer
, device_list
);
191 list_for_each(q
, &timer
->open_list_head
) {
192 master
= list_entry(q
, struct snd_timer_instance
, open_list
);
193 if (slave
->slave_class
== master
->slave_class
&&
194 slave
->slave_id
== master
->slave_id
) {
195 list_del(&slave
->open_list
);
196 list_add_tail(&slave
->open_list
,
197 &master
->slave_list_head
);
198 spin_lock_irq(&slave_active_lock
);
199 slave
->master
= master
;
200 slave
->timer
= master
->timer
;
201 spin_unlock_irq(&slave_active_lock
);
209 * look for slave instances matching with the slave id of the given master.
210 * when found, relink the open_link of slaves.
212 * call this with register_mutex down.
214 static void snd_timer_check_master(struct snd_timer_instance
*master
)
216 struct snd_timer_instance
*slave
;
217 struct list_head
*p
, *n
;
219 /* check all pending slaves */
220 list_for_each_safe(p
, n
, &snd_timer_slave_list
) {
221 slave
= list_entry(p
, struct snd_timer_instance
, open_list
);
222 if (slave
->slave_class
== master
->slave_class
&&
223 slave
->slave_id
== master
->slave_id
) {
225 list_add_tail(p
, &master
->slave_list_head
);
226 spin_lock_irq(&slave_active_lock
);
227 slave
->master
= master
;
228 slave
->timer
= master
->timer
;
229 if (slave
->flags
& SNDRV_TIMER_IFLG_RUNNING
)
230 list_add_tail(&slave
->active_list
,
231 &master
->slave_active_head
);
232 spin_unlock_irq(&slave_active_lock
);
238 * open a timer instance
239 * when opening a master, the slave id must be here given.
241 int snd_timer_open(struct snd_timer_instance
**ti
,
242 char *owner
, struct snd_timer_id
*tid
,
243 unsigned int slave_id
)
245 struct snd_timer
*timer
;
246 struct snd_timer_instance
*timeri
= NULL
;
248 if (tid
->dev_class
== SNDRV_TIMER_CLASS_SLAVE
) {
249 /* open a slave instance */
250 if (tid
->dev_sclass
<= SNDRV_TIMER_SCLASS_NONE
||
251 tid
->dev_sclass
> SNDRV_TIMER_SCLASS_OSS_SEQUENCER
) {
252 snd_printd("invalid slave class %i\n", tid
->dev_sclass
);
255 down(®ister_mutex
);
256 timeri
= snd_timer_instance_new(owner
, NULL
);
261 timeri
->slave_class
= tid
->dev_sclass
;
262 timeri
->slave_id
= tid
->device
;
263 timeri
->flags
|= SNDRV_TIMER_IFLG_SLAVE
;
264 list_add_tail(&timeri
->open_list
, &snd_timer_slave_list
);
265 snd_timer_check_slave(timeri
);
271 /* open a master instance */
272 down(®ister_mutex
);
273 timer
= snd_timer_find(tid
);
277 snd_timer_request(tid
);
278 down(®ister_mutex
);
279 timer
= snd_timer_find(tid
);
286 if (!list_empty(&timer
->open_list_head
)) {
287 timeri
= list_entry(timer
->open_list_head
.next
,
288 struct snd_timer_instance
, open_list
);
289 if (timeri
->flags
& SNDRV_TIMER_IFLG_EXCLUSIVE
) {
294 timeri
= snd_timer_instance_new(owner
, timer
);
299 timeri
->slave_class
= tid
->dev_sclass
;
300 timeri
->slave_id
= slave_id
;
301 if (list_empty(&timer
->open_list_head
) && timer
->hw
.open
)
302 timer
->hw
.open(timer
);
303 list_add_tail(&timeri
->open_list
, &timer
->open_list_head
);
304 snd_timer_check_master(timeri
);
310 static int _snd_timer_stop(struct snd_timer_instance
*timeri
,
311 int keep_flag
, int event
);
314 * close a timer instance
316 int snd_timer_close(struct snd_timer_instance
*timeri
)
318 struct snd_timer
*timer
= NULL
;
319 struct list_head
*p
, *n
;
320 struct snd_timer_instance
*slave
;
322 snd_assert(timeri
!= NULL
, return -ENXIO
);
324 /* force to stop the timer */
325 snd_timer_stop(timeri
);
327 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
) {
328 /* wait, until the active callback is finished */
329 spin_lock_irq(&slave_active_lock
);
330 while (timeri
->flags
& SNDRV_TIMER_IFLG_CALLBACK
) {
331 spin_unlock_irq(&slave_active_lock
);
333 spin_lock_irq(&slave_active_lock
);
335 spin_unlock_irq(&slave_active_lock
);
336 down(®ister_mutex
);
337 list_del(&timeri
->open_list
);
340 timer
= timeri
->timer
;
341 /* wait, until the active callback is finished */
342 spin_lock_irq(&timer
->lock
);
343 while (timeri
->flags
& SNDRV_TIMER_IFLG_CALLBACK
) {
344 spin_unlock_irq(&timer
->lock
);
346 spin_lock_irq(&timer
->lock
);
348 spin_unlock_irq(&timer
->lock
);
349 down(®ister_mutex
);
350 list_del(&timeri
->open_list
);
351 if (timer
&& list_empty(&timer
->open_list_head
) &&
353 timer
->hw
.close(timer
);
354 /* remove slave links */
355 list_for_each_safe(p
, n
, &timeri
->slave_list_head
) {
356 slave
= list_entry(p
, struct snd_timer_instance
, open_list
);
357 spin_lock_irq(&slave_active_lock
);
358 _snd_timer_stop(slave
, 1, SNDRV_TIMER_EVENT_RESOLUTION
);
360 list_add_tail(p
, &snd_timer_slave_list
);
361 slave
->master
= NULL
;
363 spin_unlock_irq(&slave_active_lock
);
367 if (timeri
->private_free
)
368 timeri
->private_free(timeri
);
369 kfree(timeri
->owner
);
372 module_put(timer
->module
);
376 unsigned long snd_timer_resolution(struct snd_timer_instance
*timeri
)
378 struct snd_timer
* timer
;
382 if ((timer
= timeri
->timer
) != NULL
) {
383 if (timer
->hw
.c_resolution
)
384 return timer
->hw
.c_resolution(timer
);
385 return timer
->hw
.resolution
;
390 static void snd_timer_notify1(struct snd_timer_instance
*ti
, int event
)
392 struct snd_timer
*timer
;
394 unsigned long resolution
= 0;
395 struct snd_timer_instance
*ts
;
397 struct timespec tstamp
;
399 getnstimeofday(&tstamp
);
400 snd_assert(event
>= SNDRV_TIMER_EVENT_START
&&
401 event
<= SNDRV_TIMER_EVENT_PAUSE
, return);
402 if (event
== SNDRV_TIMER_EVENT_START
||
403 event
== SNDRV_TIMER_EVENT_CONTINUE
)
404 resolution
= snd_timer_resolution(ti
);
406 ti
->ccallback(ti
, SNDRV_TIMER_EVENT_START
, &tstamp
, resolution
);
407 if (ti
->flags
& SNDRV_TIMER_IFLG_SLAVE
)
412 if (timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
414 spin_lock_irqsave(&timer
->lock
, flags
);
415 list_for_each(n
, &ti
->slave_active_head
) {
416 ts
= list_entry(n
, struct snd_timer_instance
, active_list
);
418 ts
->ccallback(ti
, event
+ 100, &tstamp
, resolution
);
420 spin_unlock_irqrestore(&timer
->lock
, flags
);
423 static int snd_timer_start1(struct snd_timer
*timer
, struct snd_timer_instance
*timeri
,
424 unsigned long sticks
)
426 list_del(&timeri
->active_list
);
427 list_add_tail(&timeri
->active_list
, &timer
->active_list_head
);
428 if (timer
->running
) {
429 if (timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
431 timer
->flags
|= SNDRV_TIMER_FLG_RESCHED
;
432 timeri
->flags
|= SNDRV_TIMER_IFLG_START
;
433 return 1; /* delayed start */
435 timer
->sticks
= sticks
;
436 timer
->hw
.start(timer
);
439 timeri
->flags
|= SNDRV_TIMER_IFLG_RUNNING
;
444 static int snd_timer_start_slave(struct snd_timer_instance
*timeri
)
448 spin_lock_irqsave(&slave_active_lock
, flags
);
449 timeri
->flags
|= SNDRV_TIMER_IFLG_RUNNING
;
451 list_add_tail(&timeri
->active_list
,
452 &timeri
->master
->slave_active_head
);
453 spin_unlock_irqrestore(&slave_active_lock
, flags
);
454 return 1; /* delayed start */
458 * start the timer instance
460 int snd_timer_start(struct snd_timer_instance
*timeri
, unsigned int ticks
)
462 struct snd_timer
*timer
;
463 int result
= -EINVAL
;
466 if (timeri
== NULL
|| ticks
< 1)
468 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
) {
469 result
= snd_timer_start_slave(timeri
);
470 snd_timer_notify1(timeri
, SNDRV_TIMER_EVENT_START
);
473 timer
= timeri
->timer
;
476 spin_lock_irqsave(&timer
->lock
, flags
);
477 timeri
->ticks
= timeri
->cticks
= ticks
;
479 result
= snd_timer_start1(timer
, timeri
, ticks
);
480 spin_unlock_irqrestore(&timer
->lock
, flags
);
481 snd_timer_notify1(timeri
, SNDRV_TIMER_EVENT_START
);
485 static int _snd_timer_stop(struct snd_timer_instance
* timeri
,
486 int keep_flag
, int event
)
488 struct snd_timer
*timer
;
491 snd_assert(timeri
!= NULL
, return -ENXIO
);
493 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
) {
495 spin_lock_irqsave(&slave_active_lock
, flags
);
496 timeri
->flags
&= ~SNDRV_TIMER_IFLG_RUNNING
;
497 spin_unlock_irqrestore(&slave_active_lock
, flags
);
501 timer
= timeri
->timer
;
504 spin_lock_irqsave(&timer
->lock
, flags
);
505 list_del_init(&timeri
->ack_list
);
506 list_del_init(&timeri
->active_list
);
507 if ((timeri
->flags
& SNDRV_TIMER_IFLG_RUNNING
) &&
508 !(--timer
->running
)) {
509 timer
->hw
.stop(timer
);
510 if (timer
->flags
& SNDRV_TIMER_FLG_RESCHED
) {
511 timer
->flags
&= ~SNDRV_TIMER_FLG_RESCHED
;
512 snd_timer_reschedule(timer
, 0);
513 if (timer
->flags
& SNDRV_TIMER_FLG_CHANGE
) {
514 timer
->flags
&= ~SNDRV_TIMER_FLG_CHANGE
;
515 timer
->hw
.start(timer
);
521 ~(SNDRV_TIMER_IFLG_RUNNING
| SNDRV_TIMER_IFLG_START
);
522 spin_unlock_irqrestore(&timer
->lock
, flags
);
524 if (event
!= SNDRV_TIMER_EVENT_RESOLUTION
)
525 snd_timer_notify1(timeri
, event
);
530 * stop the timer instance.
532 * do not call this from the timer callback!
534 int snd_timer_stop(struct snd_timer_instance
*timeri
)
536 struct snd_timer
*timer
;
540 err
= _snd_timer_stop(timeri
, 0, SNDRV_TIMER_EVENT_STOP
);
543 timer
= timeri
->timer
;
544 spin_lock_irqsave(&timer
->lock
, flags
);
545 timeri
->cticks
= timeri
->ticks
;
547 spin_unlock_irqrestore(&timer
->lock
, flags
);
552 * start again.. the tick is kept.
554 int snd_timer_continue(struct snd_timer_instance
*timeri
)
556 struct snd_timer
*timer
;
557 int result
= -EINVAL
;
562 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
)
563 return snd_timer_start_slave(timeri
);
564 timer
= timeri
->timer
;
567 spin_lock_irqsave(&timer
->lock
, flags
);
571 result
= snd_timer_start1(timer
, timeri
, timer
->sticks
);
572 spin_unlock_irqrestore(&timer
->lock
, flags
);
573 snd_timer_notify1(timeri
, SNDRV_TIMER_EVENT_CONTINUE
);
578 * pause.. remember the ticks left
580 int snd_timer_pause(struct snd_timer_instance
* timeri
)
582 return _snd_timer_stop(timeri
, 0, SNDRV_TIMER_EVENT_PAUSE
);
586 * reschedule the timer
588 * start pending instances and check the scheduling ticks.
589 * when the scheduling ticks is changed set CHANGE flag to reprogram the timer.
591 static void snd_timer_reschedule(struct snd_timer
* timer
, unsigned long ticks_left
)
593 struct snd_timer_instance
*ti
;
594 unsigned long ticks
= ~0UL;
597 list_for_each(p
, &timer
->active_list_head
) {
598 ti
= list_entry(p
, struct snd_timer_instance
, active_list
);
599 if (ti
->flags
& SNDRV_TIMER_IFLG_START
) {
600 ti
->flags
&= ~SNDRV_TIMER_IFLG_START
;
601 ti
->flags
|= SNDRV_TIMER_IFLG_RUNNING
;
604 if (ti
->flags
& SNDRV_TIMER_IFLG_RUNNING
) {
605 if (ticks
> ti
->cticks
)
610 timer
->flags
&= ~SNDRV_TIMER_FLG_RESCHED
;
613 if (ticks
> timer
->hw
.ticks
)
614 ticks
= timer
->hw
.ticks
;
615 if (ticks_left
!= ticks
)
616 timer
->flags
|= SNDRV_TIMER_FLG_CHANGE
;
617 timer
->sticks
= ticks
;
624 static void snd_timer_tasklet(unsigned long arg
)
626 struct snd_timer
*timer
= (struct snd_timer
*) arg
;
627 struct snd_timer_instance
*ti
;
629 unsigned long resolution
, ticks
;
631 spin_lock(&timer
->lock
);
632 /* now process all callbacks */
633 while (!list_empty(&timer
->sack_list_head
)) {
634 p
= timer
->sack_list_head
.next
; /* get first item */
635 ti
= list_entry(p
, struct snd_timer_instance
, ack_list
);
637 /* remove from ack_list and make empty */
642 resolution
= ti
->resolution
;
644 ti
->flags
|= SNDRV_TIMER_IFLG_CALLBACK
;
645 spin_unlock(&timer
->lock
);
647 ti
->callback(ti
, resolution
, ticks
);
648 spin_lock(&timer
->lock
);
649 ti
->flags
&= ~SNDRV_TIMER_IFLG_CALLBACK
;
651 spin_unlock(&timer
->lock
);
657 * ticks_left is usually equal to timer->sticks.
660 void snd_timer_interrupt(struct snd_timer
* timer
, unsigned long ticks_left
)
662 struct snd_timer_instance
*ti
, *ts
;
663 unsigned long resolution
, ticks
;
664 struct list_head
*p
, *q
, *n
, *ack_list_head
;
671 spin_lock_irqsave(&timer
->lock
, flags
);
673 /* remember the current resolution */
674 if (timer
->hw
.c_resolution
)
675 resolution
= timer
->hw
.c_resolution(timer
);
677 resolution
= timer
->hw
.resolution
;
679 /* loop for all active instances
680 * Here we cannot use list_for_each because the active_list of a
681 * processed instance is relinked to done_list_head before the callback
684 list_for_each_safe(p
, n
, &timer
->active_list_head
) {
685 ti
= list_entry(p
, struct snd_timer_instance
, active_list
);
686 if (!(ti
->flags
& SNDRV_TIMER_IFLG_RUNNING
))
688 ti
->pticks
+= ticks_left
;
689 ti
->resolution
= resolution
;
690 if (ti
->cticks
< ticks_left
)
693 ti
->cticks
-= ticks_left
;
694 if (ti
->cticks
) /* not expired */
696 if (ti
->flags
& SNDRV_TIMER_IFLG_AUTO
) {
697 ti
->cticks
= ti
->ticks
;
699 ti
->flags
&= ~SNDRV_TIMER_IFLG_RUNNING
;
700 if (--timer
->running
)
703 if ((timer
->hw
.flags
& SNDRV_TIMER_HW_TASKLET
) ||
704 (ti
->flags
& SNDRV_TIMER_IFLG_FAST
))
705 ack_list_head
= &timer
->ack_list_head
;
707 ack_list_head
= &timer
->sack_list_head
;
708 if (list_empty(&ti
->ack_list
))
709 list_add_tail(&ti
->ack_list
, ack_list_head
);
710 list_for_each(q
, &ti
->slave_active_head
) {
711 ts
= list_entry(q
, struct snd_timer_instance
, active_list
);
712 ts
->pticks
= ti
->pticks
;
713 ts
->resolution
= resolution
;
714 if (list_empty(&ts
->ack_list
))
715 list_add_tail(&ts
->ack_list
, ack_list_head
);
718 if (timer
->flags
& SNDRV_TIMER_FLG_RESCHED
)
719 snd_timer_reschedule(timer
, ticks_left
);
720 if (timer
->running
) {
721 if (timer
->hw
.flags
& SNDRV_TIMER_HW_STOP
) {
722 timer
->hw
.stop(timer
);
723 timer
->flags
|= SNDRV_TIMER_FLG_CHANGE
;
725 if (!(timer
->hw
.flags
& SNDRV_TIMER_HW_AUTO
) ||
726 (timer
->flags
& SNDRV_TIMER_FLG_CHANGE
)) {
728 timer
->flags
&= ~SNDRV_TIMER_FLG_CHANGE
;
729 timer
->hw
.start(timer
);
732 timer
->hw
.stop(timer
);
735 /* now process all fast callbacks */
736 while (!list_empty(&timer
->ack_list_head
)) {
737 p
= timer
->ack_list_head
.next
; /* get first item */
738 ti
= list_entry(p
, struct snd_timer_instance
, ack_list
);
740 /* remove from ack_list and make empty */
746 ti
->flags
|= SNDRV_TIMER_IFLG_CALLBACK
;
747 spin_unlock(&timer
->lock
);
749 ti
->callback(ti
, resolution
, ticks
);
750 spin_lock(&timer
->lock
);
751 ti
->flags
&= ~SNDRV_TIMER_IFLG_CALLBACK
;
754 /* do we have any slow callbacks? */
755 use_tasklet
= !list_empty(&timer
->sack_list_head
);
756 spin_unlock_irqrestore(&timer
->lock
, flags
);
759 tasklet_hi_schedule(&timer
->task_queue
);
766 int snd_timer_new(struct snd_card
*card
, char *id
, struct snd_timer_id
*tid
,
767 struct snd_timer
**rtimer
)
769 struct snd_timer
*timer
;
771 static struct snd_device_ops ops
= {
772 .dev_free
= snd_timer_dev_free
,
773 .dev_register
= snd_timer_dev_register
,
774 .dev_unregister
= snd_timer_dev_unregister
777 snd_assert(tid
!= NULL
, return -EINVAL
);
778 snd_assert(rtimer
!= NULL
, return -EINVAL
);
780 timer
= kzalloc(sizeof(*timer
), GFP_KERNEL
);
782 snd_printk(KERN_ERR
"timer: cannot allocate\n");
785 timer
->tmr_class
= tid
->dev_class
;
787 timer
->tmr_device
= tid
->device
;
788 timer
->tmr_subdevice
= tid
->subdevice
;
790 strlcpy(timer
->id
, id
, sizeof(timer
->id
));
791 INIT_LIST_HEAD(&timer
->device_list
);
792 INIT_LIST_HEAD(&timer
->open_list_head
);
793 INIT_LIST_HEAD(&timer
->active_list_head
);
794 INIT_LIST_HEAD(&timer
->ack_list_head
);
795 INIT_LIST_HEAD(&timer
->sack_list_head
);
796 spin_lock_init(&timer
->lock
);
797 tasklet_init(&timer
->task_queue
, snd_timer_tasklet
,
798 (unsigned long)timer
);
800 timer
->module
= card
->module
;
801 err
= snd_device_new(card
, SNDRV_DEV_TIMER
, timer
, &ops
);
803 snd_timer_free(timer
);
811 static int snd_timer_free(struct snd_timer
*timer
)
813 snd_assert(timer
!= NULL
, return -ENXIO
);
814 if (timer
->private_free
)
815 timer
->private_free(timer
);
820 static int snd_timer_dev_free(struct snd_device
*device
)
822 struct snd_timer
*timer
= device
->device_data
;
823 return snd_timer_free(timer
);
826 static int snd_timer_dev_register(struct snd_device
*dev
)
828 struct snd_timer
*timer
= dev
->device_data
;
829 struct snd_timer
*timer1
;
832 snd_assert(timer
!= NULL
&& timer
->hw
.start
!= NULL
&&
833 timer
->hw
.stop
!= NULL
, return -ENXIO
);
834 if (!(timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
) &&
835 !timer
->hw
.resolution
&& timer
->hw
.c_resolution
== NULL
)
838 down(®ister_mutex
);
839 list_for_each(p
, &snd_timer_list
) {
840 timer1
= list_entry(p
, struct snd_timer
, device_list
);
841 if (timer1
->tmr_class
> timer
->tmr_class
)
843 if (timer1
->tmr_class
< timer
->tmr_class
)
845 if (timer1
->card
&& timer
->card
) {
846 if (timer1
->card
->number
> timer
->card
->number
)
848 if (timer1
->card
->number
< timer
->card
->number
)
851 if (timer1
->tmr_device
> timer
->tmr_device
)
853 if (timer1
->tmr_device
< timer
->tmr_device
)
855 if (timer1
->tmr_subdevice
> timer
->tmr_subdevice
)
857 if (timer1
->tmr_subdevice
< timer
->tmr_subdevice
)
863 list_add_tail(&timer
->device_list
, p
);
868 static int snd_timer_unregister(struct snd_timer
*timer
)
870 struct list_head
*p
, *n
;
871 struct snd_timer_instance
*ti
;
873 snd_assert(timer
!= NULL
, return -ENXIO
);
874 down(®ister_mutex
);
875 if (! list_empty(&timer
->open_list_head
)) {
876 snd_printk(KERN_WARNING
"timer 0x%lx is busy?\n", (long)timer
);
877 list_for_each_safe(p
, n
, &timer
->open_list_head
) {
879 ti
= list_entry(p
, struct snd_timer_instance
, open_list
);
883 list_del(&timer
->device_list
);
885 return snd_timer_free(timer
);
888 static int snd_timer_dev_unregister(struct snd_device
*device
)
890 struct snd_timer
*timer
= device
->device_data
;
891 return snd_timer_unregister(timer
);
894 void snd_timer_notify(struct snd_timer
*timer
, int event
, struct timespec
*tstamp
)
897 unsigned long resolution
= 0;
898 struct snd_timer_instance
*ti
, *ts
;
899 struct list_head
*p
, *n
;
901 if (! (timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
))
903 snd_assert(event
>= SNDRV_TIMER_EVENT_MSTART
&&
904 event
<= SNDRV_TIMER_EVENT_MRESUME
, return);
905 spin_lock_irqsave(&timer
->lock
, flags
);
906 if (event
== SNDRV_TIMER_EVENT_MSTART
||
907 event
== SNDRV_TIMER_EVENT_MCONTINUE
||
908 event
== SNDRV_TIMER_EVENT_MRESUME
) {
909 if (timer
->hw
.c_resolution
)
910 resolution
= timer
->hw
.c_resolution(timer
);
912 resolution
= timer
->hw
.resolution
;
914 list_for_each(p
, &timer
->active_list_head
) {
915 ti
= list_entry(p
, struct snd_timer_instance
, active_list
);
917 ti
->ccallback(ti
, event
, tstamp
, resolution
);
918 list_for_each(n
, &ti
->slave_active_head
) {
919 ts
= list_entry(n
, struct snd_timer_instance
, active_list
);
921 ts
->ccallback(ts
, event
, tstamp
, resolution
);
924 spin_unlock_irqrestore(&timer
->lock
, flags
);
928 * exported functions for global timers
930 int snd_timer_global_new(char *id
, int device
, struct snd_timer
**rtimer
)
932 struct snd_timer_id tid
;
934 tid
.dev_class
= SNDRV_TIMER_CLASS_GLOBAL
;
935 tid
.dev_sclass
= SNDRV_TIMER_SCLASS_NONE
;
939 return snd_timer_new(NULL
, id
, &tid
, rtimer
);
942 int snd_timer_global_free(struct snd_timer
*timer
)
944 return snd_timer_free(timer
);
947 int snd_timer_global_register(struct snd_timer
*timer
)
949 struct snd_device dev
;
951 memset(&dev
, 0, sizeof(dev
));
952 dev
.device_data
= timer
;
953 return snd_timer_dev_register(&dev
);
956 int snd_timer_global_unregister(struct snd_timer
*timer
)
958 return snd_timer_unregister(timer
);
965 struct snd_timer_system_private
{
966 struct timer_list tlist
;
967 struct timer
* timer
;
968 unsigned long last_expires
;
969 unsigned long last_jiffies
;
970 unsigned long correction
;
973 static void snd_timer_s_function(unsigned long data
)
975 struct snd_timer
*timer
= (struct snd_timer
*)data
;
976 struct snd_timer_system_private
*priv
= timer
->private_data
;
977 unsigned long jiff
= jiffies
;
978 if (time_after(jiff
, priv
->last_expires
))
979 priv
->correction
= (long)jiff
- (long)priv
->last_expires
;
980 snd_timer_interrupt(timer
, (long)jiff
- (long)priv
->last_jiffies
);
983 static int snd_timer_s_start(struct snd_timer
* timer
)
985 struct snd_timer_system_private
*priv
;
988 priv
= (struct snd_timer_system_private
*) timer
->private_data
;
989 njiff
= (priv
->last_jiffies
= jiffies
);
990 if (priv
->correction
> timer
->sticks
- 1) {
991 priv
->correction
-= timer
->sticks
- 1;
994 njiff
+= timer
->sticks
- priv
->correction
;
995 priv
->correction
-= timer
->sticks
;
997 priv
->last_expires
= priv
->tlist
.expires
= njiff
;
998 add_timer(&priv
->tlist
);
1002 static int snd_timer_s_stop(struct snd_timer
* timer
)
1004 struct snd_timer_system_private
*priv
;
1007 priv
= (struct snd_timer_system_private
*) timer
->private_data
;
1008 del_timer(&priv
->tlist
);
1010 if (time_before(jiff
, priv
->last_expires
))
1011 timer
->sticks
= priv
->last_expires
- jiff
;
1017 static struct snd_timer_hardware snd_timer_system
=
1019 .flags
= SNDRV_TIMER_HW_FIRST
| SNDRV_TIMER_HW_TASKLET
,
1020 .resolution
= 1000000000L / HZ
,
1022 .start
= snd_timer_s_start
,
1023 .stop
= snd_timer_s_stop
1026 static void snd_timer_free_system(struct snd_timer
*timer
)
1028 kfree(timer
->private_data
);
1031 static int snd_timer_register_system(void)
1033 struct snd_timer
*timer
;
1034 struct snd_timer_system_private
*priv
;
1037 err
= snd_timer_global_new("system", SNDRV_TIMER_GLOBAL_SYSTEM
, &timer
);
1040 strcpy(timer
->name
, "system timer");
1041 timer
->hw
= snd_timer_system
;
1042 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
1044 snd_timer_free(timer
);
1047 init_timer(&priv
->tlist
);
1048 priv
->tlist
.function
= snd_timer_s_function
;
1049 priv
->tlist
.data
= (unsigned long) timer
;
1050 timer
->private_data
= priv
;
1051 timer
->private_free
= snd_timer_free_system
;
1052 return snd_timer_global_register(timer
);
1059 static void snd_timer_proc_read(struct snd_info_entry
*entry
,
1060 struct snd_info_buffer
*buffer
)
1062 unsigned long flags
;
1063 struct snd_timer
*timer
;
1064 struct snd_timer_instance
*ti
;
1065 struct list_head
*p
, *q
;
1067 down(®ister_mutex
);
1068 list_for_each(p
, &snd_timer_list
) {
1069 timer
= list_entry(p
, struct snd_timer
, device_list
);
1070 switch (timer
->tmr_class
) {
1071 case SNDRV_TIMER_CLASS_GLOBAL
:
1072 snd_iprintf(buffer
, "G%i: ", timer
->tmr_device
);
1074 case SNDRV_TIMER_CLASS_CARD
:
1075 snd_iprintf(buffer
, "C%i-%i: ",
1076 timer
->card
->number
, timer
->tmr_device
);
1078 case SNDRV_TIMER_CLASS_PCM
:
1079 snd_iprintf(buffer
, "P%i-%i-%i: ", timer
->card
->number
,
1080 timer
->tmr_device
, timer
->tmr_subdevice
);
1083 snd_iprintf(buffer
, "?%i-%i-%i-%i: ", timer
->tmr_class
,
1084 timer
->card
? timer
->card
->number
: -1,
1085 timer
->tmr_device
, timer
->tmr_subdevice
);
1087 snd_iprintf(buffer
, "%s :", timer
->name
);
1088 if (timer
->hw
.resolution
)
1089 snd_iprintf(buffer
, " %lu.%03luus (%lu ticks)",
1090 timer
->hw
.resolution
/ 1000,
1091 timer
->hw
.resolution
% 1000,
1093 if (timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
1094 snd_iprintf(buffer
, " SLAVE");
1095 snd_iprintf(buffer
, "\n");
1096 spin_lock_irqsave(&timer
->lock
, flags
);
1097 list_for_each(q
, &timer
->open_list_head
) {
1098 ti
= list_entry(q
, struct snd_timer_instance
, open_list
);
1099 snd_iprintf(buffer
, " Client %s : %s\n",
1100 ti
->owner
? ti
->owner
: "unknown",
1101 ti
->flags
& (SNDRV_TIMER_IFLG_START
|
1102 SNDRV_TIMER_IFLG_RUNNING
)
1103 ? "running" : "stopped");
1105 spin_unlock_irqrestore(&timer
->lock
, flags
);
1107 up(®ister_mutex
);
1111 * USER SPACE interface
1114 static void snd_timer_user_interrupt(struct snd_timer_instance
*timeri
,
1115 unsigned long resolution
,
1116 unsigned long ticks
)
1118 struct snd_timer_user
*tu
= timeri
->callback_data
;
1119 struct snd_timer_read
*r
;
1122 spin_lock(&tu
->qlock
);
1123 if (tu
->qused
> 0) {
1124 prev
= tu
->qtail
== 0 ? tu
->queue_size
- 1 : tu
->qtail
- 1;
1125 r
= &tu
->queue
[prev
];
1126 if (r
->resolution
== resolution
) {
1131 if (tu
->qused
>= tu
->queue_size
) {
1134 r
= &tu
->queue
[tu
->qtail
++];
1135 tu
->qtail
%= tu
->queue_size
;
1136 r
->resolution
= resolution
;
1141 spin_unlock(&tu
->qlock
);
1142 kill_fasync(&tu
->fasync
, SIGIO
, POLL_IN
);
1143 wake_up(&tu
->qchange_sleep
);
1146 static void snd_timer_user_append_to_tqueue(struct snd_timer_user
*tu
,
1147 struct snd_timer_tread
*tread
)
1149 if (tu
->qused
>= tu
->queue_size
) {
1152 memcpy(&tu
->tqueue
[tu
->qtail
++], tread
, sizeof(*tread
));
1153 tu
->qtail
%= tu
->queue_size
;
1158 static void snd_timer_user_ccallback(struct snd_timer_instance
*timeri
,
1160 struct timespec
*tstamp
,
1161 unsigned long resolution
)
1163 struct snd_timer_user
*tu
= timeri
->callback_data
;
1164 struct snd_timer_tread r1
;
1166 if (event
>= SNDRV_TIMER_EVENT_START
&&
1167 event
<= SNDRV_TIMER_EVENT_PAUSE
)
1168 tu
->tstamp
= *tstamp
;
1169 if ((tu
->filter
& (1 << event
)) == 0 || !tu
->tread
)
1172 r1
.tstamp
= *tstamp
;
1173 r1
.val
= resolution
;
1174 spin_lock(&tu
->qlock
);
1175 snd_timer_user_append_to_tqueue(tu
, &r1
);
1176 spin_unlock(&tu
->qlock
);
1177 kill_fasync(&tu
->fasync
, SIGIO
, POLL_IN
);
1178 wake_up(&tu
->qchange_sleep
);
1181 static void snd_timer_user_tinterrupt(struct snd_timer_instance
*timeri
,
1182 unsigned long resolution
,
1183 unsigned long ticks
)
1185 struct snd_timer_user
*tu
= timeri
->callback_data
;
1186 struct snd_timer_tread
*r
, r1
;
1187 struct timespec tstamp
;
1188 int prev
, append
= 0;
1190 memset(&tstamp
, 0, sizeof(tstamp
));
1191 spin_lock(&tu
->qlock
);
1192 if ((tu
->filter
& ((1 << SNDRV_TIMER_EVENT_RESOLUTION
) |
1193 (1 << SNDRV_TIMER_EVENT_TICK
))) == 0) {
1194 spin_unlock(&tu
->qlock
);
1197 if (tu
->last_resolution
!= resolution
|| ticks
> 0)
1198 getnstimeofday(&tstamp
);
1199 if ((tu
->filter
& (1 << SNDRV_TIMER_EVENT_RESOLUTION
)) &&
1200 tu
->last_resolution
!= resolution
) {
1201 r1
.event
= SNDRV_TIMER_EVENT_RESOLUTION
;
1203 r1
.val
= resolution
;
1204 snd_timer_user_append_to_tqueue(tu
, &r1
);
1205 tu
->last_resolution
= resolution
;
1208 if ((tu
->filter
& (1 << SNDRV_TIMER_EVENT_TICK
)) == 0)
1212 if (tu
->qused
> 0) {
1213 prev
= tu
->qtail
== 0 ? tu
->queue_size
- 1 : tu
->qtail
- 1;
1214 r
= &tu
->tqueue
[prev
];
1215 if (r
->event
== SNDRV_TIMER_EVENT_TICK
) {
1222 r1
.event
= SNDRV_TIMER_EVENT_TICK
;
1225 snd_timer_user_append_to_tqueue(tu
, &r1
);
1228 spin_unlock(&tu
->qlock
);
1231 kill_fasync(&tu
->fasync
, SIGIO
, POLL_IN
);
1232 wake_up(&tu
->qchange_sleep
);
1235 static int snd_timer_user_open(struct inode
*inode
, struct file
*file
)
1237 struct snd_timer_user
*tu
;
1239 tu
= kzalloc(sizeof(*tu
), GFP_KERNEL
);
1242 spin_lock_init(&tu
->qlock
);
1243 init_waitqueue_head(&tu
->qchange_sleep
);
1244 init_MUTEX(&tu
->tread_sem
);
1246 tu
->queue_size
= 128;
1247 tu
->queue
= kmalloc(tu
->queue_size
* sizeof(struct snd_timer_read
),
1249 if (tu
->queue
== NULL
) {
1253 file
->private_data
= tu
;
1257 static int snd_timer_user_release(struct inode
*inode
, struct file
*file
)
1259 struct snd_timer_user
*tu
;
1261 if (file
->private_data
) {
1262 tu
= file
->private_data
;
1263 file
->private_data
= NULL
;
1264 fasync_helper(-1, file
, 0, &tu
->fasync
);
1266 snd_timer_close(tu
->timeri
);
1274 static void snd_timer_user_zero_id(struct snd_timer_id
*id
)
1276 id
->dev_class
= SNDRV_TIMER_CLASS_NONE
;
1277 id
->dev_sclass
= SNDRV_TIMER_SCLASS_NONE
;
1283 static void snd_timer_user_copy_id(struct snd_timer_id
*id
, struct snd_timer
*timer
)
1285 id
->dev_class
= timer
->tmr_class
;
1286 id
->dev_sclass
= SNDRV_TIMER_SCLASS_NONE
;
1287 id
->card
= timer
->card
? timer
->card
->number
: -1;
1288 id
->device
= timer
->tmr_device
;
1289 id
->subdevice
= timer
->tmr_subdevice
;
1292 static int snd_timer_user_next_device(struct snd_timer_id __user
*_tid
)
1294 struct snd_timer_id id
;
1295 struct snd_timer
*timer
;
1296 struct list_head
*p
;
1298 if (copy_from_user(&id
, _tid
, sizeof(id
)))
1300 down(®ister_mutex
);
1301 if (id
.dev_class
< 0) { /* first item */
1302 if (list_empty(&snd_timer_list
))
1303 snd_timer_user_zero_id(&id
);
1305 timer
= list_entry(snd_timer_list
.next
,
1306 struct snd_timer
, device_list
);
1307 snd_timer_user_copy_id(&id
, timer
);
1310 switch (id
.dev_class
) {
1311 case SNDRV_TIMER_CLASS_GLOBAL
:
1312 id
.device
= id
.device
< 0 ? 0 : id
.device
+ 1;
1313 list_for_each(p
, &snd_timer_list
) {
1314 timer
= list_entry(p
, struct snd_timer
, device_list
);
1315 if (timer
->tmr_class
> SNDRV_TIMER_CLASS_GLOBAL
) {
1316 snd_timer_user_copy_id(&id
, timer
);
1319 if (timer
->tmr_device
>= id
.device
) {
1320 snd_timer_user_copy_id(&id
, timer
);
1324 if (p
== &snd_timer_list
)
1325 snd_timer_user_zero_id(&id
);
1327 case SNDRV_TIMER_CLASS_CARD
:
1328 case SNDRV_TIMER_CLASS_PCM
:
1335 if (id
.device
< 0) {
1338 if (id
.subdevice
< 0) {
1346 list_for_each(p
, &snd_timer_list
) {
1347 timer
= list_entry(p
, struct snd_timer
, device_list
);
1348 if (timer
->tmr_class
> id
.dev_class
) {
1349 snd_timer_user_copy_id(&id
, timer
);
1352 if (timer
->tmr_class
< id
.dev_class
)
1354 if (timer
->card
->number
> id
.card
) {
1355 snd_timer_user_copy_id(&id
, timer
);
1358 if (timer
->card
->number
< id
.card
)
1360 if (timer
->tmr_device
> id
.device
) {
1361 snd_timer_user_copy_id(&id
, timer
);
1364 if (timer
->tmr_device
< id
.device
)
1366 if (timer
->tmr_subdevice
> id
.subdevice
) {
1367 snd_timer_user_copy_id(&id
, timer
);
1370 if (timer
->tmr_subdevice
< id
.subdevice
)
1372 snd_timer_user_copy_id(&id
, timer
);
1375 if (p
== &snd_timer_list
)
1376 snd_timer_user_zero_id(&id
);
1379 snd_timer_user_zero_id(&id
);
1382 up(®ister_mutex
);
1383 if (copy_to_user(_tid
, &id
, sizeof(*_tid
)))
1388 static int snd_timer_user_ginfo(struct file
*file
,
1389 struct snd_timer_ginfo __user
*_ginfo
)
1391 struct snd_timer_ginfo
*ginfo
;
1392 struct snd_timer_id tid
;
1393 struct snd_timer
*t
;
1394 struct list_head
*p
;
1397 ginfo
= kmalloc(sizeof(*ginfo
), GFP_KERNEL
);
1400 if (copy_from_user(ginfo
, _ginfo
, sizeof(*ginfo
))) {
1405 memset(ginfo
, 0, sizeof(*ginfo
));
1407 down(®ister_mutex
);
1408 t
= snd_timer_find(&tid
);
1410 ginfo
->card
= t
->card
? t
->card
->number
: -1;
1411 if (t
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
1412 ginfo
->flags
|= SNDRV_TIMER_FLG_SLAVE
;
1413 strlcpy(ginfo
->id
, t
->id
, sizeof(ginfo
->id
));
1414 strlcpy(ginfo
->name
, t
->name
, sizeof(ginfo
->name
));
1415 ginfo
->resolution
= t
->hw
.resolution
;
1416 if (t
->hw
.resolution_min
> 0) {
1417 ginfo
->resolution_min
= t
->hw
.resolution_min
;
1418 ginfo
->resolution_max
= t
->hw
.resolution_max
;
1420 list_for_each(p
, &t
->open_list_head
) {
1426 up(®ister_mutex
);
1427 if (err
>= 0 && copy_to_user(_ginfo
, ginfo
, sizeof(*ginfo
)))
1433 static int snd_timer_user_gparams(struct file
*file
,
1434 struct snd_timer_gparams __user
*_gparams
)
1436 struct snd_timer_gparams gparams
;
1437 struct snd_timer
*t
;
1440 if (copy_from_user(&gparams
, _gparams
, sizeof(gparams
)))
1442 down(®ister_mutex
);
1443 t
= snd_timer_find(&gparams
.tid
);
1448 if (!list_empty(&t
->open_list_head
)) {
1452 if (!t
->hw
.set_period
) {
1456 err
= t
->hw
.set_period(t
, gparams
.period_num
, gparams
.period_den
);
1458 up(®ister_mutex
);
1462 static int snd_timer_user_gstatus(struct file
*file
,
1463 struct snd_timer_gstatus __user
*_gstatus
)
1465 struct snd_timer_gstatus gstatus
;
1466 struct snd_timer_id tid
;
1467 struct snd_timer
*t
;
1470 if (copy_from_user(&gstatus
, _gstatus
, sizeof(gstatus
)))
1473 memset(&gstatus
, 0, sizeof(gstatus
));
1475 down(®ister_mutex
);
1476 t
= snd_timer_find(&tid
);
1478 if (t
->hw
.c_resolution
)
1479 gstatus
.resolution
= t
->hw
.c_resolution(t
);
1481 gstatus
.resolution
= t
->hw
.resolution
;
1482 if (t
->hw
.precise_resolution
) {
1483 t
->hw
.precise_resolution(t
, &gstatus
.resolution_num
,
1484 &gstatus
.resolution_den
);
1486 gstatus
.resolution_num
= gstatus
.resolution
;
1487 gstatus
.resolution_den
= 1000000000uL;
1492 up(®ister_mutex
);
1493 if (err
>= 0 && copy_to_user(_gstatus
, &gstatus
, sizeof(gstatus
)))
1498 static int snd_timer_user_tselect(struct file
*file
,
1499 struct snd_timer_select __user
*_tselect
)
1501 struct snd_timer_user
*tu
;
1502 struct snd_timer_select tselect
;
1506 tu
= file
->private_data
;
1507 down(&tu
->tread_sem
);
1509 snd_timer_close(tu
->timeri
);
1512 if (copy_from_user(&tselect
, _tselect
, sizeof(tselect
))) {
1516 sprintf(str
, "application %i", current
->pid
);
1517 if (tselect
.id
.dev_class
!= SNDRV_TIMER_CLASS_SLAVE
)
1518 tselect
.id
.dev_sclass
= SNDRV_TIMER_SCLASS_APPLICATION
;
1519 err
= snd_timer_open(&tu
->timeri
, str
, &tselect
.id
, current
->pid
);
1528 tu
->tqueue
= kmalloc(tu
->queue_size
* sizeof(struct snd_timer_tread
),
1530 if (tu
->tqueue
== NULL
)
1533 tu
->queue
= kmalloc(tu
->queue_size
* sizeof(struct snd_timer_read
),
1535 if (tu
->queue
== NULL
)
1540 snd_timer_close(tu
->timeri
);
1543 tu
->timeri
->flags
|= SNDRV_TIMER_IFLG_FAST
;
1544 tu
->timeri
->callback
= tu
->tread
1545 ? snd_timer_user_tinterrupt
: snd_timer_user_interrupt
;
1546 tu
->timeri
->ccallback
= snd_timer_user_ccallback
;
1547 tu
->timeri
->callback_data
= (void *)tu
;
1555 static int snd_timer_user_info(struct file
*file
,
1556 struct snd_timer_info __user
*_info
)
1558 struct snd_timer_user
*tu
;
1559 struct snd_timer_info
*info
;
1560 struct snd_timer
*t
;
1563 tu
= file
->private_data
;
1564 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1565 t
= tu
->timeri
->timer
;
1566 snd_assert(t
!= NULL
, return -ENXIO
);
1568 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
1571 info
->card
= t
->card
? t
->card
->number
: -1;
1572 if (t
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
1573 info
->flags
|= SNDRV_TIMER_FLG_SLAVE
;
1574 strlcpy(info
->id
, t
->id
, sizeof(info
->id
));
1575 strlcpy(info
->name
, t
->name
, sizeof(info
->name
));
1576 info
->resolution
= t
->hw
.resolution
;
1577 if (copy_to_user(_info
, info
, sizeof(*_info
)))
1583 static int snd_timer_user_params(struct file
*file
,
1584 struct snd_timer_params __user
*_params
)
1586 struct snd_timer_user
*tu
;
1587 struct snd_timer_params params
;
1588 struct snd_timer
*t
;
1589 struct snd_timer_read
*tr
;
1590 struct snd_timer_tread
*ttr
;
1593 tu
= file
->private_data
;
1594 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1595 t
= tu
->timeri
->timer
;
1596 snd_assert(t
!= NULL
, return -ENXIO
);
1597 if (copy_from_user(¶ms
, _params
, sizeof(params
)))
1599 if (!(t
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
) && params
.ticks
< 1) {
1603 if (params
.queue_size
> 0 &&
1604 (params
.queue_size
< 32 || params
.queue_size
> 1024)) {
1608 if (params
.filter
& ~((1<<SNDRV_TIMER_EVENT_RESOLUTION
)|
1609 (1<<SNDRV_TIMER_EVENT_TICK
)|
1610 (1<<SNDRV_TIMER_EVENT_START
)|
1611 (1<<SNDRV_TIMER_EVENT_STOP
)|
1612 (1<<SNDRV_TIMER_EVENT_CONTINUE
)|
1613 (1<<SNDRV_TIMER_EVENT_PAUSE
)|
1614 (1<<SNDRV_TIMER_EVENT_SUSPEND
)|
1615 (1<<SNDRV_TIMER_EVENT_RESUME
)|
1616 (1<<SNDRV_TIMER_EVENT_MSTART
)|
1617 (1<<SNDRV_TIMER_EVENT_MSTOP
)|
1618 (1<<SNDRV_TIMER_EVENT_MCONTINUE
)|
1619 (1<<SNDRV_TIMER_EVENT_MPAUSE
)|
1620 (1<<SNDRV_TIMER_EVENT_MSUSPEND
)|
1621 (1<<SNDRV_TIMER_EVENT_MRESUME
))) {
1625 snd_timer_stop(tu
->timeri
);
1626 spin_lock_irq(&t
->lock
);
1627 tu
->timeri
->flags
&= ~(SNDRV_TIMER_IFLG_AUTO
|
1628 SNDRV_TIMER_IFLG_EXCLUSIVE
|
1629 SNDRV_TIMER_IFLG_EARLY_EVENT
);
1630 if (params
.flags
& SNDRV_TIMER_PSFLG_AUTO
)
1631 tu
->timeri
->flags
|= SNDRV_TIMER_IFLG_AUTO
;
1632 if (params
.flags
& SNDRV_TIMER_PSFLG_EXCLUSIVE
)
1633 tu
->timeri
->flags
|= SNDRV_TIMER_IFLG_EXCLUSIVE
;
1634 if (params
.flags
& SNDRV_TIMER_PSFLG_EARLY_EVENT
)
1635 tu
->timeri
->flags
|= SNDRV_TIMER_IFLG_EARLY_EVENT
;
1636 spin_unlock_irq(&t
->lock
);
1637 if (params
.queue_size
> 0 &&
1638 (unsigned int)tu
->queue_size
!= params
.queue_size
) {
1640 ttr
= kmalloc(params
.queue_size
* sizeof(*ttr
),
1644 tu
->queue_size
= params
.queue_size
;
1648 tr
= kmalloc(params
.queue_size
* sizeof(*tr
),
1652 tu
->queue_size
= params
.queue_size
;
1657 tu
->qhead
= tu
->qtail
= tu
->qused
= 0;
1658 if (tu
->timeri
->flags
& SNDRV_TIMER_IFLG_EARLY_EVENT
) {
1660 struct snd_timer_tread tread
;
1661 tread
.event
= SNDRV_TIMER_EVENT_EARLY
;
1662 tread
.tstamp
.tv_sec
= 0;
1663 tread
.tstamp
.tv_nsec
= 0;
1665 snd_timer_user_append_to_tqueue(tu
, &tread
);
1667 struct snd_timer_read
*r
= &tu
->queue
[0];
1674 tu
->filter
= params
.filter
;
1675 tu
->ticks
= params
.ticks
;
1678 if (copy_to_user(_params
, ¶ms
, sizeof(params
)))
1683 static int snd_timer_user_status(struct file
*file
,
1684 struct snd_timer_status __user
*_status
)
1686 struct snd_timer_user
*tu
;
1687 struct snd_timer_status status
;
1689 tu
= file
->private_data
;
1690 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1691 memset(&status
, 0, sizeof(status
));
1692 status
.tstamp
= tu
->tstamp
;
1693 status
.resolution
= snd_timer_resolution(tu
->timeri
);
1694 status
.lost
= tu
->timeri
->lost
;
1695 status
.overrun
= tu
->overrun
;
1696 spin_lock_irq(&tu
->qlock
);
1697 status
.queue
= tu
->qused
;
1698 spin_unlock_irq(&tu
->qlock
);
1699 if (copy_to_user(_status
, &status
, sizeof(status
)))
1704 static int snd_timer_user_start(struct file
*file
)
1707 struct snd_timer_user
*tu
;
1709 tu
= file
->private_data
;
1710 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1711 snd_timer_stop(tu
->timeri
);
1712 tu
->timeri
->lost
= 0;
1713 tu
->last_resolution
= 0;
1714 return (err
= snd_timer_start(tu
->timeri
, tu
->ticks
)) < 0 ? err
: 0;
1717 static int snd_timer_user_stop(struct file
*file
)
1720 struct snd_timer_user
*tu
;
1722 tu
= file
->private_data
;
1723 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1724 return (err
= snd_timer_stop(tu
->timeri
)) < 0 ? err
: 0;
1727 static int snd_timer_user_continue(struct file
*file
)
1730 struct snd_timer_user
*tu
;
1732 tu
= file
->private_data
;
1733 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1734 tu
->timeri
->lost
= 0;
1735 return (err
= snd_timer_continue(tu
->timeri
)) < 0 ? err
: 0;
1738 static int snd_timer_user_pause(struct file
*file
)
1741 struct snd_timer_user
*tu
;
1743 tu
= file
->private_data
;
1744 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1745 return (err
= snd_timer_pause(tu
->timeri
)) < 0 ? err
: 0;
1749 SNDRV_TIMER_IOCTL_START_OLD
= _IO('T', 0x20),
1750 SNDRV_TIMER_IOCTL_STOP_OLD
= _IO('T', 0x21),
1751 SNDRV_TIMER_IOCTL_CONTINUE_OLD
= _IO('T', 0x22),
1752 SNDRV_TIMER_IOCTL_PAUSE_OLD
= _IO('T', 0x23),
1755 static long snd_timer_user_ioctl(struct file
*file
, unsigned int cmd
,
1758 struct snd_timer_user
*tu
;
1759 void __user
*argp
= (void __user
*)arg
;
1760 int __user
*p
= argp
;
1762 tu
= file
->private_data
;
1764 case SNDRV_TIMER_IOCTL_PVERSION
:
1765 return put_user(SNDRV_TIMER_VERSION
, p
) ? -EFAULT
: 0;
1766 case SNDRV_TIMER_IOCTL_NEXT_DEVICE
:
1767 return snd_timer_user_next_device(argp
);
1768 case SNDRV_TIMER_IOCTL_TREAD
:
1772 down(&tu
->tread_sem
);
1773 if (tu
->timeri
) { /* too late */
1777 if (get_user(xarg
, p
)) {
1781 tu
->tread
= xarg
? 1 : 0;
1785 case SNDRV_TIMER_IOCTL_GINFO
:
1786 return snd_timer_user_ginfo(file
, argp
);
1787 case SNDRV_TIMER_IOCTL_GPARAMS
:
1788 return snd_timer_user_gparams(file
, argp
);
1789 case SNDRV_TIMER_IOCTL_GSTATUS
:
1790 return snd_timer_user_gstatus(file
, argp
);
1791 case SNDRV_TIMER_IOCTL_SELECT
:
1792 return snd_timer_user_tselect(file
, argp
);
1793 case SNDRV_TIMER_IOCTL_INFO
:
1794 return snd_timer_user_info(file
, argp
);
1795 case SNDRV_TIMER_IOCTL_PARAMS
:
1796 return snd_timer_user_params(file
, argp
);
1797 case SNDRV_TIMER_IOCTL_STATUS
:
1798 return snd_timer_user_status(file
, argp
);
1799 case SNDRV_TIMER_IOCTL_START
:
1800 case SNDRV_TIMER_IOCTL_START_OLD
:
1801 return snd_timer_user_start(file
);
1802 case SNDRV_TIMER_IOCTL_STOP
:
1803 case SNDRV_TIMER_IOCTL_STOP_OLD
:
1804 return snd_timer_user_stop(file
);
1805 case SNDRV_TIMER_IOCTL_CONTINUE
:
1806 case SNDRV_TIMER_IOCTL_CONTINUE_OLD
:
1807 return snd_timer_user_continue(file
);
1808 case SNDRV_TIMER_IOCTL_PAUSE
:
1809 case SNDRV_TIMER_IOCTL_PAUSE_OLD
:
1810 return snd_timer_user_pause(file
);
1815 static int snd_timer_user_fasync(int fd
, struct file
* file
, int on
)
1817 struct snd_timer_user
*tu
;
1820 tu
= file
->private_data
;
1821 err
= fasync_helper(fd
, file
, on
, &tu
->fasync
);
1827 static ssize_t
snd_timer_user_read(struct file
*file
, char __user
*buffer
,
1828 size_t count
, loff_t
*offset
)
1830 struct snd_timer_user
*tu
;
1831 long result
= 0, unit
;
1834 tu
= file
->private_data
;
1835 unit
= tu
->tread
? sizeof(struct snd_timer_tread
) : sizeof(struct snd_timer_read
);
1836 spin_lock_irq(&tu
->qlock
);
1837 while ((long)count
- result
>= unit
) {
1838 while (!tu
->qused
) {
1841 if ((file
->f_flags
& O_NONBLOCK
) != 0 || result
> 0) {
1846 set_current_state(TASK_INTERRUPTIBLE
);
1847 init_waitqueue_entry(&wait
, current
);
1848 add_wait_queue(&tu
->qchange_sleep
, &wait
);
1850 spin_unlock_irq(&tu
->qlock
);
1852 spin_lock_irq(&tu
->qlock
);
1854 remove_wait_queue(&tu
->qchange_sleep
, &wait
);
1856 if (signal_pending(current
)) {
1862 spin_unlock_irq(&tu
->qlock
);
1867 if (copy_to_user(buffer
, &tu
->tqueue
[tu
->qhead
++],
1868 sizeof(struct snd_timer_tread
))) {
1873 if (copy_to_user(buffer
, &tu
->queue
[tu
->qhead
++],
1874 sizeof(struct snd_timer_read
))) {
1880 tu
->qhead
%= tu
->queue_size
;
1885 spin_lock_irq(&tu
->qlock
);
1888 spin_unlock_irq(&tu
->qlock
);
1890 return result
> 0 ? result
: err
;
1893 static unsigned int snd_timer_user_poll(struct file
*file
, poll_table
* wait
)
1896 struct snd_timer_user
*tu
;
1898 tu
= file
->private_data
;
1900 poll_wait(file
, &tu
->qchange_sleep
, wait
);
1904 mask
|= POLLIN
| POLLRDNORM
;
1909 #ifdef CONFIG_COMPAT
1910 #include "timer_compat.c"
1912 #define snd_timer_user_ioctl_compat NULL
1915 static struct file_operations snd_timer_f_ops
=
1917 .owner
= THIS_MODULE
,
1918 .read
= snd_timer_user_read
,
1919 .open
= snd_timer_user_open
,
1920 .release
= snd_timer_user_release
,
1921 .poll
= snd_timer_user_poll
,
1922 .unlocked_ioctl
= snd_timer_user_ioctl
,
1923 .compat_ioctl
= snd_timer_user_ioctl_compat
,
1924 .fasync
= snd_timer_user_fasync
,
1931 static struct snd_info_entry
*snd_timer_proc_entry
= NULL
;
1933 static int __init
alsa_timer_init(void)
1936 struct snd_info_entry
*entry
;
1938 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
1939 snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS
, SNDRV_CARDS
- 1,
1942 entry
= snd_info_create_module_entry(THIS_MODULE
, "timers", NULL
);
1943 if (entry
!= NULL
) {
1944 entry
->c
.text
.read_size
= SNDRV_TIMER_DEVICES
* 128;
1945 entry
->c
.text
.read
= snd_timer_proc_read
;
1946 if (snd_info_register(entry
) < 0) {
1947 snd_info_free_entry(entry
);
1951 snd_timer_proc_entry
= entry
;
1952 if ((err
= snd_timer_register_system()) < 0)
1953 snd_printk(KERN_ERR
"unable to register system timer (%i)\n",
1955 if ((err
= snd_register_device(SNDRV_DEVICE_TYPE_TIMER
,
1956 NULL
, 0, &snd_timer_f_ops
, "timer")) < 0)
1957 snd_printk(KERN_ERR
"unable to register timer device (%i)\n",
1962 static void __exit
alsa_timer_exit(void)
1964 struct list_head
*p
, *n
;
1966 snd_unregister_device(SNDRV_DEVICE_TYPE_TIMER
, NULL
, 0);
1967 /* unregister the system timer */
1968 list_for_each_safe(p
, n
, &snd_timer_list
) {
1969 struct snd_timer
*timer
= list_entry(p
, struct snd_timer
, device_list
);
1970 snd_timer_unregister(timer
);
1972 if (snd_timer_proc_entry
) {
1973 snd_info_unregister(snd_timer_proc_entry
);
1974 snd_timer_proc_entry
= NULL
;
1976 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
1977 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS
, SNDRV_CARDS
- 1);
1981 module_init(alsa_timer_init
)
1982 module_exit(alsa_timer_exit
)
1984 EXPORT_SYMBOL(snd_timer_open
);
1985 EXPORT_SYMBOL(snd_timer_close
);
1986 EXPORT_SYMBOL(snd_timer_resolution
);
1987 EXPORT_SYMBOL(snd_timer_start
);
1988 EXPORT_SYMBOL(snd_timer_stop
);
1989 EXPORT_SYMBOL(snd_timer_continue
);
1990 EXPORT_SYMBOL(snd_timer_pause
);
1991 EXPORT_SYMBOL(snd_timer_new
);
1992 EXPORT_SYMBOL(snd_timer_notify
);
1993 EXPORT_SYMBOL(snd_timer_global_new
);
1994 EXPORT_SYMBOL(snd_timer_global_free
);
1995 EXPORT_SYMBOL(snd_timer_global_register
);
1996 EXPORT_SYMBOL(snd_timer_global_unregister
);
1997 EXPORT_SYMBOL(snd_timer_interrupt
);