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 <sound/core.h>
30 #include <sound/timer.h>
31 #include <sound/control.h>
32 #include <sound/info.h>
33 #include <sound/minors.h>
34 #include <sound/initval.h>
35 #include <linux/kmod.h>
37 #include <linux/kerneld.h>
40 #if defined(CONFIG_SND_HPET) || defined(CONFIG_SND_HPET_MODULE)
41 #define DEFAULT_TIMER_LIMIT 3
42 #elif defined(CONFIG_SND_RTCTIMER) || defined(CONFIG_SND_RTCTIMER_MODULE)
43 #define DEFAULT_TIMER_LIMIT 2
45 #define DEFAULT_TIMER_LIMIT 1
48 static int timer_limit
= DEFAULT_TIMER_LIMIT
;
49 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Takashi Iwai <tiwai@suse.de>");
50 MODULE_DESCRIPTION("ALSA timer interface");
51 MODULE_LICENSE("GPL");
52 module_param(timer_limit
, int, 0444);
53 MODULE_PARM_DESC(timer_limit
, "Maximum global timers in system.");
56 snd_timer_instance_t
*timeri
;
57 int tread
; /* enhanced read with timestamps and events */
59 unsigned long overrun
;
64 snd_timer_read_t
*queue
;
65 snd_timer_tread_t
*tqueue
;
67 unsigned long last_resolution
;
69 struct timespec tstamp
; /* trigger tstamp */
70 wait_queue_head_t qchange_sleep
;
71 struct fasync_struct
*fasync
;
72 struct semaphore tread_sem
;
76 static LIST_HEAD(snd_timer_list
);
78 /* list of slave instances */
79 static LIST_HEAD(snd_timer_slave_list
);
81 /* lock for slave active lists */
82 static DEFINE_SPINLOCK(slave_active_lock
);
84 static DECLARE_MUTEX(register_mutex
);
86 static int snd_timer_free(snd_timer_t
*timer
);
87 static int snd_timer_dev_free(snd_device_t
*device
);
88 static int snd_timer_dev_register(snd_device_t
*device
);
89 static int snd_timer_dev_unregister(snd_device_t
*device
);
91 static void snd_timer_reschedule(snd_timer_t
* timer
, unsigned long ticks_left
);
94 * create a timer instance with the given owner string.
95 * when timer is not NULL, increments the module counter
97 static snd_timer_instance_t
*snd_timer_instance_new(char *owner
, snd_timer_t
*timer
)
99 snd_timer_instance_t
*timeri
;
100 timeri
= kcalloc(1, sizeof(*timeri
), GFP_KERNEL
);
103 timeri
->owner
= snd_kmalloc_strdup(owner
, GFP_KERNEL
);
104 if (! timeri
->owner
) {
108 INIT_LIST_HEAD(&timeri
->open_list
);
109 INIT_LIST_HEAD(&timeri
->active_list
);
110 INIT_LIST_HEAD(&timeri
->ack_list
);
111 INIT_LIST_HEAD(&timeri
->slave_list_head
);
112 INIT_LIST_HEAD(&timeri
->slave_active_head
);
114 timeri
->timer
= timer
;
115 if (timer
&& timer
->card
&& !try_module_get(timer
->card
->module
)) {
116 kfree(timeri
->owner
);
125 * find a timer instance from the given timer id
127 static snd_timer_t
*snd_timer_find(snd_timer_id_t
*tid
)
129 snd_timer_t
*timer
= NULL
;
132 list_for_each(p
, &snd_timer_list
) {
133 timer
= (snd_timer_t
*)list_entry(p
, snd_timer_t
, device_list
);
135 if (timer
->tmr_class
!= tid
->dev_class
)
137 if ((timer
->tmr_class
== SNDRV_TIMER_CLASS_CARD
||
138 timer
->tmr_class
== SNDRV_TIMER_CLASS_PCM
) &&
139 (timer
->card
== NULL
||
140 timer
->card
->number
!= tid
->card
))
142 if (timer
->tmr_device
!= tid
->device
)
144 if (timer
->tmr_subdevice
!= tid
->subdevice
)
153 static void snd_timer_request(snd_timer_id_t
*tid
)
155 if (! current
->fs
->root
)
157 switch (tid
->dev_class
) {
158 case SNDRV_TIMER_CLASS_GLOBAL
:
159 if (tid
->device
< timer_limit
)
160 request_module("snd-timer-%i", tid
->device
);
162 case SNDRV_TIMER_CLASS_CARD
:
163 case SNDRV_TIMER_CLASS_PCM
:
164 if (tid
->card
< snd_ecards_limit
)
165 request_module("snd-card-%i", tid
->card
);
175 * look for a master instance matching with the slave id of the given slave.
176 * when found, relink the open_link of the slave.
178 * call this with register_mutex down.
180 static void snd_timer_check_slave(snd_timer_instance_t
*slave
)
183 snd_timer_instance_t
*master
;
184 struct list_head
*p
, *q
;
186 /* FIXME: it's really dumb to look up all entries.. */
187 list_for_each(p
, &snd_timer_list
) {
188 timer
= (snd_timer_t
*)list_entry(p
, snd_timer_t
, device_list
);
189 list_for_each(q
, &timer
->open_list_head
) {
190 master
= (snd_timer_instance_t
*)list_entry(q
, snd_timer_instance_t
, open_list
);
191 if (slave
->slave_class
== master
->slave_class
&&
192 slave
->slave_id
== master
->slave_id
) {
193 list_del(&slave
->open_list
);
194 list_add_tail(&slave
->open_list
, &master
->slave_list_head
);
195 spin_lock_irq(&slave_active_lock
);
196 slave
->master
= master
;
197 slave
->timer
= master
->timer
;
198 spin_unlock_irq(&slave_active_lock
);
206 * look for slave instances matching with the slave id of the given master.
207 * when found, relink the open_link of slaves.
209 * call this with register_mutex down.
211 static void snd_timer_check_master(snd_timer_instance_t
*master
)
213 snd_timer_instance_t
*slave
;
214 struct list_head
*p
, *n
;
216 /* check all pending slaves */
217 list_for_each_safe(p
, n
, &snd_timer_slave_list
) {
218 slave
= (snd_timer_instance_t
*)list_entry(p
, snd_timer_instance_t
, open_list
);
219 if (slave
->slave_class
== master
->slave_class
&&
220 slave
->slave_id
== master
->slave_id
) {
222 list_add_tail(p
, &master
->slave_list_head
);
223 spin_lock_irq(&slave_active_lock
);
224 slave
->master
= master
;
225 slave
->timer
= master
->timer
;
226 if (slave
->flags
& SNDRV_TIMER_IFLG_RUNNING
)
227 list_add_tail(&slave
->active_list
, &master
->slave_active_head
);
228 spin_unlock_irq(&slave_active_lock
);
234 * open a timer instance
235 * when opening a master, the slave id must be here given.
237 int snd_timer_open(snd_timer_instance_t
**ti
,
238 char *owner
, snd_timer_id_t
*tid
,
239 unsigned int slave_id
)
242 snd_timer_instance_t
*timeri
= NULL
;
244 if (tid
->dev_class
== SNDRV_TIMER_CLASS_SLAVE
) {
245 /* open a slave instance */
246 if (tid
->dev_sclass
<= SNDRV_TIMER_SCLASS_NONE
||
247 tid
->dev_sclass
> SNDRV_TIMER_SCLASS_OSS_SEQUENCER
) {
248 snd_printd("invalid slave class %i\n", tid
->dev_sclass
);
251 down(®ister_mutex
);
252 timeri
= snd_timer_instance_new(owner
, NULL
);
253 timeri
->slave_class
= tid
->dev_sclass
;
254 timeri
->slave_id
= tid
->device
;
255 timeri
->flags
|= SNDRV_TIMER_IFLG_SLAVE
;
256 list_add_tail(&timeri
->open_list
, &snd_timer_slave_list
);
257 snd_timer_check_slave(timeri
);
263 /* open a master instance */
264 down(®ister_mutex
);
265 timer
= snd_timer_find(tid
);
269 snd_timer_request(tid
);
270 down(®ister_mutex
);
271 timer
= snd_timer_find(tid
);
275 if (!list_empty(&timer
->open_list_head
)) {
276 timeri
= (snd_timer_instance_t
*)list_entry(timer
->open_list_head
.next
, snd_timer_instance_t
, open_list
);
277 if (timeri
->flags
& SNDRV_TIMER_IFLG_EXCLUSIVE
) {
282 timeri
= snd_timer_instance_new(owner
, timer
);
284 timeri
->slave_class
= tid
->dev_sclass
;
285 timeri
->slave_id
= slave_id
;
286 if (list_empty(&timer
->open_list_head
) && timer
->hw
.open
)
287 timer
->hw
.open(timer
);
288 list_add_tail(&timeri
->open_list
, &timer
->open_list_head
);
289 snd_timer_check_master(timeri
);
300 static int _snd_timer_stop(snd_timer_instance_t
* timeri
, int keep_flag
, enum sndrv_timer_event event
);
303 * close a timer instance
305 int snd_timer_close(snd_timer_instance_t
* timeri
)
307 snd_timer_t
*timer
= NULL
;
308 struct list_head
*p
, *n
;
309 snd_timer_instance_t
*slave
;
311 snd_assert(timeri
!= NULL
, return -ENXIO
);
313 /* force to stop the timer */
314 snd_timer_stop(timeri
);
316 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
) {
317 /* wait, until the active callback is finished */
318 spin_lock_irq(&slave_active_lock
);
319 while (timeri
->flags
& SNDRV_TIMER_IFLG_CALLBACK
) {
320 spin_unlock_irq(&slave_active_lock
);
322 spin_lock_irq(&slave_active_lock
);
324 spin_unlock_irq(&slave_active_lock
);
325 down(®ister_mutex
);
326 list_del(&timeri
->open_list
);
329 timer
= timeri
->timer
;
330 /* wait, until the active callback is finished */
331 spin_lock_irq(&timer
->lock
);
332 while (timeri
->flags
& SNDRV_TIMER_IFLG_CALLBACK
) {
333 spin_unlock_irq(&timer
->lock
);
335 spin_lock_irq(&timer
->lock
);
337 spin_unlock_irq(&timer
->lock
);
338 down(®ister_mutex
);
339 list_del(&timeri
->open_list
);
340 if (timer
&& list_empty(&timer
->open_list_head
) && timer
->hw
.close
)
341 timer
->hw
.close(timer
);
342 /* remove slave links */
343 list_for_each_safe(p
, n
, &timeri
->slave_list_head
) {
344 slave
= (snd_timer_instance_t
*)list_entry(p
, snd_timer_instance_t
, open_list
);
345 spin_lock_irq(&slave_active_lock
);
346 _snd_timer_stop(slave
, 1, SNDRV_TIMER_EVENT_RESOLUTION
);
348 list_add_tail(p
, &snd_timer_slave_list
);
349 slave
->master
= NULL
;
351 spin_unlock_irq(&slave_active_lock
);
355 if (timeri
->private_free
)
356 timeri
->private_free(timeri
);
357 kfree(timeri
->owner
);
359 if (timer
&& timer
->card
)
360 module_put(timer
->card
->module
);
364 unsigned long snd_timer_resolution(snd_timer_instance_t
* timeri
)
370 if ((timer
= timeri
->timer
) != NULL
) {
371 if (timer
->hw
.c_resolution
)
372 return timer
->hw
.c_resolution(timer
);
373 return timer
->hw
.resolution
;
378 static void snd_timer_notify1(snd_timer_instance_t
*ti
, enum sndrv_timer_event event
)
382 unsigned long resolution
= 0;
383 snd_timer_instance_t
*ts
;
385 struct timespec tstamp
;
387 snd_timestamp_now(&tstamp
, 1);
388 snd_assert(event
>= SNDRV_TIMER_EVENT_START
&& event
<= SNDRV_TIMER_EVENT_PAUSE
, return);
389 if (event
== SNDRV_TIMER_EVENT_START
|| event
== SNDRV_TIMER_EVENT_CONTINUE
)
390 resolution
= snd_timer_resolution(ti
);
392 ti
->ccallback(ti
, SNDRV_TIMER_EVENT_START
, &tstamp
, resolution
);
393 if (ti
->flags
& SNDRV_TIMER_IFLG_SLAVE
)
398 if (timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
400 spin_lock_irqsave(&timer
->lock
, flags
);
401 list_for_each(n
, &ti
->slave_active_head
) {
402 ts
= (snd_timer_instance_t
*)list_entry(n
, snd_timer_instance_t
, active_list
);
404 ts
->ccallback(ti
, event
+ 100, &tstamp
, resolution
);
406 spin_unlock_irqrestore(&timer
->lock
, flags
);
409 static int snd_timer_start1(snd_timer_t
*timer
, snd_timer_instance_t
*timeri
, unsigned long sticks
)
411 list_del(&timeri
->active_list
);
412 list_add_tail(&timeri
->active_list
, &timer
->active_list_head
);
413 if (timer
->running
) {
414 if (timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
416 timer
->flags
|= SNDRV_TIMER_FLG_RESCHED
;
417 timeri
->flags
|= SNDRV_TIMER_IFLG_START
;
418 return 1; /* delayed start */
420 timer
->sticks
= sticks
;
421 timer
->hw
.start(timer
);
424 timeri
->flags
|= SNDRV_TIMER_IFLG_RUNNING
;
429 static int snd_timer_start_slave(snd_timer_instance_t
*timeri
)
433 spin_lock_irqsave(&slave_active_lock
, flags
);
434 timeri
->flags
|= SNDRV_TIMER_IFLG_RUNNING
;
436 list_add_tail(&timeri
->active_list
, &timeri
->master
->slave_active_head
);
437 spin_unlock_irqrestore(&slave_active_lock
, flags
);
438 return 1; /* delayed start */
442 * start the timer instance
444 int snd_timer_start(snd_timer_instance_t
* timeri
, unsigned int ticks
)
447 int result
= -EINVAL
;
450 if (timeri
== NULL
|| ticks
< 1)
452 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
) {
453 result
= snd_timer_start_slave(timeri
);
454 snd_timer_notify1(timeri
, SNDRV_TIMER_EVENT_START
);
457 timer
= timeri
->timer
;
460 spin_lock_irqsave(&timer
->lock
, flags
);
461 timeri
->ticks
= timeri
->cticks
= ticks
;
463 result
= snd_timer_start1(timer
, timeri
, ticks
);
464 spin_unlock_irqrestore(&timer
->lock
, flags
);
465 snd_timer_notify1(timeri
, SNDRV_TIMER_EVENT_START
);
469 static int _snd_timer_stop(snd_timer_instance_t
* timeri
, int keep_flag
, enum sndrv_timer_event event
)
474 snd_assert(timeri
!= NULL
, return -ENXIO
);
476 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
) {
478 spin_lock_irqsave(&slave_active_lock
, flags
);
479 timeri
->flags
&= ~SNDRV_TIMER_IFLG_RUNNING
;
480 spin_unlock_irqrestore(&slave_active_lock
, flags
);
484 timer
= timeri
->timer
;
487 spin_lock_irqsave(&timer
->lock
, flags
);
488 list_del_init(&timeri
->ack_list
);
489 list_del_init(&timeri
->active_list
);
490 if ((timeri
->flags
& SNDRV_TIMER_IFLG_RUNNING
) &&
491 !(--timer
->running
)) {
492 timer
->hw
.stop(timer
);
493 if (timer
->flags
& SNDRV_TIMER_FLG_RESCHED
) {
494 timer
->flags
&= ~SNDRV_TIMER_FLG_RESCHED
;
495 snd_timer_reschedule(timer
, 0);
496 if (timer
->flags
& SNDRV_TIMER_FLG_CHANGE
) {
497 timer
->flags
&= ~SNDRV_TIMER_FLG_CHANGE
;
498 timer
->hw
.start(timer
);
503 timeri
->flags
&= ~(SNDRV_TIMER_IFLG_RUNNING
|SNDRV_TIMER_IFLG_START
);
504 spin_unlock_irqrestore(&timer
->lock
, flags
);
506 if (event
!= SNDRV_TIMER_EVENT_RESOLUTION
)
507 snd_timer_notify1(timeri
, event
);
512 * stop the timer instance.
514 * do not call this from the timer callback!
516 int snd_timer_stop(snd_timer_instance_t
* timeri
)
522 err
= _snd_timer_stop(timeri
, 0, SNDRV_TIMER_EVENT_STOP
);
525 timer
= timeri
->timer
;
526 spin_lock_irqsave(&timer
->lock
, flags
);
527 timeri
->cticks
= timeri
->ticks
;
529 spin_unlock_irqrestore(&timer
->lock
, flags
);
534 * start again.. the tick is kept.
536 int snd_timer_continue(snd_timer_instance_t
* timeri
)
539 int result
= -EINVAL
;
544 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
)
545 return snd_timer_start_slave(timeri
);
546 timer
= timeri
->timer
;
549 spin_lock_irqsave(&timer
->lock
, flags
);
553 result
= snd_timer_start1(timer
, timeri
, timer
->sticks
);
554 spin_unlock_irqrestore(&timer
->lock
, flags
);
555 snd_timer_notify1(timeri
, SNDRV_TIMER_EVENT_CONTINUE
);
560 * pause.. remember the ticks left
562 int snd_timer_pause(snd_timer_instance_t
* timeri
)
564 return _snd_timer_stop(timeri
, 0, SNDRV_TIMER_EVENT_PAUSE
);
568 * reschedule the timer
570 * start pending instances and check the scheduling ticks.
571 * when the scheduling ticks is changed set CHANGE flag to reprogram the timer.
573 static void snd_timer_reschedule(snd_timer_t
* timer
, unsigned long ticks_left
)
575 snd_timer_instance_t
*ti
;
576 unsigned long ticks
= ~0UL;
579 list_for_each(p
, &timer
->active_list_head
) {
580 ti
= (snd_timer_instance_t
*)list_entry(p
, snd_timer_instance_t
, active_list
);
581 if (ti
->flags
& SNDRV_TIMER_IFLG_START
) {
582 ti
->flags
&= ~SNDRV_TIMER_IFLG_START
;
583 ti
->flags
|= SNDRV_TIMER_IFLG_RUNNING
;
586 if (ti
->flags
& SNDRV_TIMER_IFLG_RUNNING
) {
587 if (ticks
> ti
->cticks
)
592 timer
->flags
&= ~SNDRV_TIMER_FLG_RESCHED
;
595 if (ticks
> timer
->hw
.ticks
)
596 ticks
= timer
->hw
.ticks
;
597 if (ticks_left
!= ticks
)
598 timer
->flags
|= SNDRV_TIMER_FLG_CHANGE
;
599 timer
->sticks
= ticks
;
606 static void snd_timer_tasklet(unsigned long arg
)
608 snd_timer_t
*timer
= (snd_timer_t
*) arg
;
609 snd_timer_instance_t
*ti
;
611 unsigned long resolution
, ticks
;
613 spin_lock(&timer
->lock
);
614 /* now process all callbacks */
615 while (!list_empty(&timer
->sack_list_head
)) {
616 p
= timer
->sack_list_head
.next
; /* get first item */
617 ti
= (snd_timer_instance_t
*)list_entry(p
, snd_timer_instance_t
, ack_list
);
619 /* remove from ack_list and make empty */
624 resolution
= ti
->resolution
;
626 ti
->flags
|= SNDRV_TIMER_IFLG_CALLBACK
;
627 spin_unlock(&timer
->lock
);
629 ti
->callback(ti
, resolution
, ticks
);
630 spin_lock(&timer
->lock
);
631 ti
->flags
&= ~SNDRV_TIMER_IFLG_CALLBACK
;
633 spin_unlock(&timer
->lock
);
639 * ticks_left is usually equal to timer->sticks.
642 void snd_timer_interrupt(snd_timer_t
* timer
, unsigned long ticks_left
)
644 snd_timer_instance_t
*ti
, *ts
;
645 unsigned long resolution
, ticks
;
646 struct list_head
*p
, *q
, *n
;
652 spin_lock(&timer
->lock
);
654 /* remember the current resolution */
655 if (timer
->hw
.c_resolution
)
656 resolution
= timer
->hw
.c_resolution(timer
);
658 resolution
= timer
->hw
.resolution
;
660 /* loop for all active instances
661 * here we cannot use list_for_each because the active_list of a processed
662 * instance is relinked to done_list_head before callback is called.
664 list_for_each_safe(p
, n
, &timer
->active_list_head
) {
665 ti
= (snd_timer_instance_t
*)list_entry(p
, snd_timer_instance_t
, active_list
);
666 if (!(ti
->flags
& SNDRV_TIMER_IFLG_RUNNING
))
668 ti
->pticks
+= ticks_left
;
669 ti
->resolution
= resolution
;
670 if (ti
->cticks
< ticks_left
)
673 ti
->cticks
-= ticks_left
;
674 if (ti
->cticks
) /* not expired */
676 if (ti
->flags
& SNDRV_TIMER_IFLG_AUTO
) {
677 ti
->cticks
= ti
->ticks
;
679 ti
->flags
&= ~SNDRV_TIMER_IFLG_RUNNING
;
680 if (--timer
->running
)
683 if (list_empty(&ti
->ack_list
)) {
684 if ((timer
->hw
.flags
& SNDRV_TIMER_HW_TASKLET
) ||
685 (ti
->flags
& SNDRV_TIMER_IFLG_FAST
)) {
686 list_add_tail(&ti
->ack_list
, &timer
->ack_list_head
);
688 list_add_tail(&ti
->ack_list
, &timer
->sack_list_head
);
691 list_for_each(q
, &ti
->slave_active_head
) {
692 ts
= (snd_timer_instance_t
*)list_entry(q
, snd_timer_instance_t
, active_list
);
693 ts
->pticks
= ti
->pticks
;
694 ts
->resolution
= resolution
;
695 if (list_empty(&ts
->ack_list
)) {
696 if ((timer
->hw
.flags
& SNDRV_TIMER_HW_TASKLET
) ||
697 (ti
->flags
& SNDRV_TIMER_IFLG_FAST
)) {
698 list_add_tail(&ts
->ack_list
, &timer
->ack_list_head
);
700 list_add_tail(&ts
->ack_list
, &timer
->sack_list_head
);
705 if (timer
->flags
& SNDRV_TIMER_FLG_RESCHED
)
706 snd_timer_reschedule(timer
, ticks_left
);
707 if (timer
->running
) {
708 if (timer
->hw
.flags
& SNDRV_TIMER_HW_STOP
) {
709 timer
->hw
.stop(timer
);
710 timer
->flags
|= SNDRV_TIMER_FLG_CHANGE
;
712 if (!(timer
->hw
.flags
& SNDRV_TIMER_HW_AUTO
) ||
713 (timer
->flags
& SNDRV_TIMER_FLG_CHANGE
)) {
715 timer
->flags
&= ~SNDRV_TIMER_FLG_CHANGE
;
716 timer
->hw
.start(timer
);
719 timer
->hw
.stop(timer
);
722 /* now process all fast callbacks */
723 while (!list_empty(&timer
->ack_list_head
)) {
724 p
= timer
->ack_list_head
.next
; /* get first item */
725 ti
= (snd_timer_instance_t
*)list_entry(p
, snd_timer_instance_t
, ack_list
);
727 /* remove from ack_list and make empty */
733 ti
->flags
|= SNDRV_TIMER_IFLG_CALLBACK
;
734 spin_unlock(&timer
->lock
);
736 ti
->callback(ti
, resolution
, ticks
);
737 spin_lock(&timer
->lock
);
738 ti
->flags
&= ~SNDRV_TIMER_IFLG_CALLBACK
;
741 /* do we have any slow callbacks? */
742 use_tasklet
= !list_empty(&timer
->sack_list_head
);
743 spin_unlock(&timer
->lock
);
746 tasklet_hi_schedule(&timer
->task_queue
);
753 int snd_timer_new(snd_card_t
*card
, char *id
, snd_timer_id_t
*tid
, snd_timer_t
** rtimer
)
757 static snd_device_ops_t ops
= {
758 .dev_free
= snd_timer_dev_free
,
759 .dev_register
= snd_timer_dev_register
,
760 .dev_unregister
= snd_timer_dev_unregister
763 snd_assert(tid
!= NULL
, return -EINVAL
);
764 snd_assert(rtimer
!= NULL
, return -EINVAL
);
766 timer
= kcalloc(1, sizeof(*timer
), GFP_KERNEL
);
769 timer
->tmr_class
= tid
->dev_class
;
771 timer
->tmr_device
= tid
->device
;
772 timer
->tmr_subdevice
= tid
->subdevice
;
774 strlcpy(timer
->id
, id
, sizeof(timer
->id
));
775 INIT_LIST_HEAD(&timer
->device_list
);
776 INIT_LIST_HEAD(&timer
->open_list_head
);
777 INIT_LIST_HEAD(&timer
->active_list_head
);
778 INIT_LIST_HEAD(&timer
->ack_list_head
);
779 INIT_LIST_HEAD(&timer
->sack_list_head
);
780 spin_lock_init(&timer
->lock
);
781 tasklet_init(&timer
->task_queue
, snd_timer_tasklet
, (unsigned long)timer
);
783 if ((err
= snd_device_new(card
, SNDRV_DEV_TIMER
, timer
, &ops
)) < 0) {
784 snd_timer_free(timer
);
792 static int snd_timer_free(snd_timer_t
*timer
)
794 snd_assert(timer
!= NULL
, return -ENXIO
);
795 if (timer
->private_free
)
796 timer
->private_free(timer
);
801 int snd_timer_dev_free(snd_device_t
*device
)
803 snd_timer_t
*timer
= device
->device_data
;
804 return snd_timer_free(timer
);
807 int snd_timer_dev_register(snd_device_t
*dev
)
809 snd_timer_t
*timer
= dev
->device_data
;
813 snd_assert(timer
!= NULL
&& timer
->hw
.start
!= NULL
&& timer
->hw
.stop
!= NULL
, return -ENXIO
);
814 if (!(timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
) &&
815 !timer
->hw
.resolution
&& timer
->hw
.c_resolution
== NULL
)
818 down(®ister_mutex
);
819 list_for_each(p
, &snd_timer_list
) {
820 timer1
= (snd_timer_t
*)list_entry(p
, snd_timer_t
, device_list
);
821 if (timer1
->tmr_class
> timer
->tmr_class
)
823 if (timer1
->tmr_class
< timer
->tmr_class
)
825 if (timer1
->card
&& timer
->card
) {
826 if (timer1
->card
->number
> timer
->card
->number
)
828 if (timer1
->card
->number
< timer
->card
->number
)
831 if (timer1
->tmr_device
> timer
->tmr_device
)
833 if (timer1
->tmr_device
< timer
->tmr_device
)
835 if (timer1
->tmr_subdevice
> timer
->tmr_subdevice
)
837 if (timer1
->tmr_subdevice
< timer
->tmr_subdevice
)
843 list_add_tail(&timer
->device_list
, p
);
848 static int snd_timer_unregister(snd_timer_t
*timer
)
850 struct list_head
*p
, *n
;
851 snd_timer_instance_t
*ti
;
853 snd_assert(timer
!= NULL
, return -ENXIO
);
854 down(®ister_mutex
);
855 if (! list_empty(&timer
->open_list_head
)) {
856 snd_printk(KERN_WARNING
"timer 0x%lx is busy?\n", (long)timer
);
857 list_for_each_safe(p
, n
, &timer
->open_list_head
) {
859 ti
= (snd_timer_instance_t
*)list_entry(p
, snd_timer_instance_t
, open_list
);
863 list_del(&timer
->device_list
);
865 return snd_timer_free(timer
);
868 static int snd_timer_dev_unregister(snd_device_t
*device
)
870 snd_timer_t
*timer
= device
->device_data
;
871 return snd_timer_unregister(timer
);
874 void snd_timer_notify(snd_timer_t
*timer
, enum sndrv_timer_event event
, struct timespec
*tstamp
)
877 unsigned long resolution
= 0;
878 snd_timer_instance_t
*ti
, *ts
;
879 struct list_head
*p
, *n
;
881 snd_runtime_check(timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
, return);
882 snd_assert(event
>= SNDRV_TIMER_EVENT_MSTART
&& event
<= SNDRV_TIMER_EVENT_MPAUSE
, return);
883 spin_lock_irqsave(&timer
->lock
, flags
);
884 if (event
== SNDRV_TIMER_EVENT_MSTART
|| event
== SNDRV_TIMER_EVENT_MCONTINUE
) {
885 if (timer
->hw
.c_resolution
)
886 resolution
= timer
->hw
.c_resolution(timer
);
888 resolution
= timer
->hw
.resolution
;
890 list_for_each(p
, &timer
->active_list_head
) {
891 ti
= (snd_timer_instance_t
*)list_entry(p
, snd_timer_instance_t
, active_list
);
893 ti
->ccallback(ti
, event
, tstamp
, resolution
);
894 list_for_each(n
, &ti
->slave_active_head
) {
895 ts
= (snd_timer_instance_t
*)list_entry(n
, snd_timer_instance_t
, active_list
);
897 ts
->ccallback(ts
, event
, tstamp
, resolution
);
900 spin_unlock_irqrestore(&timer
->lock
, flags
);
904 * exported functions for global timers
906 int snd_timer_global_new(char *id
, int device
, snd_timer_t
**rtimer
)
910 tid
.dev_class
= SNDRV_TIMER_CLASS_GLOBAL
;
911 tid
.dev_sclass
= SNDRV_TIMER_SCLASS_NONE
;
915 return snd_timer_new(NULL
, id
, &tid
, rtimer
);
918 int snd_timer_global_free(snd_timer_t
*timer
)
920 return snd_timer_free(timer
);
923 int snd_timer_global_register(snd_timer_t
*timer
)
927 memset(&dev
, 0, sizeof(dev
));
928 dev
.device_data
= timer
;
929 return snd_timer_dev_register(&dev
);
932 int snd_timer_global_unregister(snd_timer_t
*timer
)
934 return snd_timer_unregister(timer
);
941 struct snd_timer_system_private
{
942 struct timer_list tlist
;
943 struct timer
* timer
;
944 unsigned long last_expires
;
945 unsigned long last_jiffies
;
946 unsigned long correction
;
949 static void snd_timer_s_function(unsigned long data
)
951 snd_timer_t
*timer
= (snd_timer_t
*)data
;
952 struct snd_timer_system_private
*priv
= timer
->private_data
;
953 unsigned long jiff
= jiffies
;
954 if (time_after(jiff
, priv
->last_expires
))
955 priv
->correction
= (long)jiff
- (long)priv
->last_expires
;
956 snd_timer_interrupt(timer
, (long)jiff
- (long)priv
->last_jiffies
);
959 static int snd_timer_s_start(snd_timer_t
* timer
)
961 struct snd_timer_system_private
*priv
;
964 priv
= (struct snd_timer_system_private
*) timer
->private_data
;
965 njiff
= (priv
->last_jiffies
= jiffies
);
966 if (priv
->correction
> timer
->sticks
- 1) {
967 priv
->correction
-= timer
->sticks
- 1;
970 njiff
+= timer
->sticks
- priv
->correction
;
971 priv
->correction
-= timer
->sticks
;
973 priv
->last_expires
= priv
->tlist
.expires
= njiff
;
974 add_timer(&priv
->tlist
);
978 static int snd_timer_s_stop(snd_timer_t
* timer
)
980 struct snd_timer_system_private
*priv
;
983 priv
= (struct snd_timer_system_private
*) timer
->private_data
;
984 del_timer(&priv
->tlist
);
986 if (time_before(jiff
, priv
->last_expires
))
987 timer
->sticks
= priv
->last_expires
- jiff
;
993 static struct _snd_timer_hardware snd_timer_system
=
995 .flags
= SNDRV_TIMER_HW_FIRST
| SNDRV_TIMER_HW_TASKLET
,
996 .resolution
= 1000000000L / HZ
,
998 .start
= snd_timer_s_start
,
999 .stop
= snd_timer_s_stop
1002 static void snd_timer_free_system(snd_timer_t
*timer
)
1004 kfree(timer
->private_data
);
1007 static int snd_timer_register_system(void)
1010 struct snd_timer_system_private
*priv
;
1013 if ((err
= snd_timer_global_new("system", SNDRV_TIMER_GLOBAL_SYSTEM
, &timer
)) < 0)
1015 strcpy(timer
->name
, "system timer");
1016 timer
->hw
= snd_timer_system
;
1017 priv
= kcalloc(1, sizeof(*priv
), GFP_KERNEL
);
1019 snd_timer_free(timer
);
1022 init_timer(&priv
->tlist
);
1023 priv
->tlist
.function
= snd_timer_s_function
;
1024 priv
->tlist
.data
= (unsigned long) timer
;
1025 timer
->private_data
= priv
;
1026 timer
->private_free
= snd_timer_free_system
;
1027 return snd_timer_global_register(timer
);
1034 static void snd_timer_proc_read(snd_info_entry_t
*entry
,
1035 snd_info_buffer_t
* buffer
)
1037 unsigned long flags
;
1039 snd_timer_instance_t
*ti
;
1040 struct list_head
*p
, *q
;
1042 down(®ister_mutex
);
1043 list_for_each(p
, &snd_timer_list
) {
1044 timer
= (snd_timer_t
*)list_entry(p
, snd_timer_t
, device_list
);
1045 switch (timer
->tmr_class
) {
1046 case SNDRV_TIMER_CLASS_GLOBAL
:
1047 snd_iprintf(buffer
, "G%i: ", timer
->tmr_device
);
1049 case SNDRV_TIMER_CLASS_CARD
:
1050 snd_iprintf(buffer
, "C%i-%i: ", timer
->card
->number
, timer
->tmr_device
);
1052 case SNDRV_TIMER_CLASS_PCM
:
1053 snd_iprintf(buffer
, "P%i-%i-%i: ", timer
->card
->number
, timer
->tmr_device
, timer
->tmr_subdevice
);
1056 snd_iprintf(buffer
, "?%i-%i-%i-%i: ", timer
->tmr_class
, timer
->card
? timer
->card
->number
: -1, timer
->tmr_device
, timer
->tmr_subdevice
);
1058 snd_iprintf(buffer
, "%s :", timer
->name
);
1059 if (timer
->hw
.resolution
)
1060 snd_iprintf(buffer
, " %lu.%03luus (%lu ticks)", timer
->hw
.resolution
/ 1000, timer
->hw
.resolution
% 1000, timer
->hw
.ticks
);
1061 if (timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
1062 snd_iprintf(buffer
, " SLAVE");
1063 snd_iprintf(buffer
, "\n");
1064 spin_lock_irqsave(&timer
->lock
, flags
);
1065 list_for_each(q
, &timer
->open_list_head
) {
1066 ti
= (snd_timer_instance_t
*)list_entry(q
, snd_timer_instance_t
, open_list
);
1067 snd_iprintf(buffer
, " Client %s : %s : lost interrupts %li\n",
1068 ti
->owner
? ti
->owner
: "unknown",
1069 ti
->flags
& (SNDRV_TIMER_IFLG_START
|SNDRV_TIMER_IFLG_RUNNING
) ? "running" : "stopped",
1072 spin_unlock_irqrestore(&timer
->lock
, flags
);
1074 up(®ister_mutex
);
1078 * USER SPACE interface
1081 static void snd_timer_user_interrupt(snd_timer_instance_t
*timeri
,
1082 unsigned long resolution
,
1083 unsigned long ticks
)
1085 snd_timer_user_t
*tu
= timeri
->callback_data
;
1086 snd_timer_read_t
*r
;
1089 spin_lock(&tu
->qlock
);
1090 if (tu
->qused
> 0) {
1091 prev
= tu
->qtail
== 0 ? tu
->queue_size
- 1 : tu
->qtail
- 1;
1092 r
= &tu
->queue
[prev
];
1093 if (r
->resolution
== resolution
) {
1098 if (tu
->qused
>= tu
->queue_size
) {
1101 r
= &tu
->queue
[tu
->qtail
++];
1102 tu
->qtail
%= tu
->queue_size
;
1103 r
->resolution
= resolution
;
1108 spin_unlock(&tu
->qlock
);
1109 kill_fasync(&tu
->fasync
, SIGIO
, POLL_IN
);
1110 wake_up(&tu
->qchange_sleep
);
1113 static void snd_timer_user_append_to_tqueue(snd_timer_user_t
*tu
, snd_timer_tread_t
*tread
)
1115 if (tu
->qused
>= tu
->queue_size
) {
1118 memcpy(&tu
->tqueue
[tu
->qtail
++], tread
, sizeof(*tread
));
1119 tu
->qtail
%= tu
->queue_size
;
1124 static void snd_timer_user_ccallback(snd_timer_instance_t
*timeri
,
1125 enum sndrv_timer_event event
,
1126 struct timespec
*tstamp
,
1127 unsigned long resolution
)
1129 snd_timer_user_t
*tu
= timeri
->callback_data
;
1130 snd_timer_tread_t r1
;
1132 if (event
>= SNDRV_TIMER_EVENT_START
&& event
<= SNDRV_TIMER_EVENT_PAUSE
)
1133 tu
->tstamp
= *tstamp
;
1134 if ((tu
->filter
& (1 << event
)) == 0 || !tu
->tread
)
1137 r1
.tstamp
= *tstamp
;
1138 r1
.val
= resolution
;
1139 spin_lock(&tu
->qlock
);
1140 snd_timer_user_append_to_tqueue(tu
, &r1
);
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_tinterrupt(snd_timer_instance_t
*timeri
,
1147 unsigned long resolution
,
1148 unsigned long ticks
)
1150 snd_timer_user_t
*tu
= timeri
->callback_data
;
1151 snd_timer_tread_t
*r
, r1
;
1152 struct timespec tstamp
;
1153 int prev
, append
= 0;
1155 snd_timestamp_zero(&tstamp
);
1156 spin_lock(&tu
->qlock
);
1157 if ((tu
->filter
& ((1 << SNDRV_TIMER_EVENT_RESOLUTION
)|(1 << SNDRV_TIMER_EVENT_TICK
))) == 0) {
1158 spin_unlock(&tu
->qlock
);
1161 if (tu
->last_resolution
!= resolution
|| ticks
> 0)
1162 snd_timestamp_now(&tstamp
, 1);
1163 if ((tu
->filter
& (1 << SNDRV_TIMER_EVENT_RESOLUTION
)) && tu
->last_resolution
!= resolution
) {
1164 r1
.event
= SNDRV_TIMER_EVENT_RESOLUTION
;
1166 r1
.val
= resolution
;
1167 snd_timer_user_append_to_tqueue(tu
, &r1
);
1168 tu
->last_resolution
= resolution
;
1171 if ((tu
->filter
& (1 << SNDRV_TIMER_EVENT_TICK
)) == 0)
1175 if (tu
->qused
> 0) {
1176 prev
= tu
->qtail
== 0 ? tu
->queue_size
- 1 : tu
->qtail
- 1;
1177 r
= &tu
->tqueue
[prev
];
1178 if (r
->event
== SNDRV_TIMER_EVENT_TICK
) {
1185 r1
.event
= SNDRV_TIMER_EVENT_TICK
;
1188 snd_timer_user_append_to_tqueue(tu
, &r1
);
1191 spin_unlock(&tu
->qlock
);
1194 kill_fasync(&tu
->fasync
, SIGIO
, POLL_IN
);
1195 wake_up(&tu
->qchange_sleep
);
1198 static int snd_timer_user_open(struct inode
*inode
, struct file
*file
)
1200 snd_timer_user_t
*tu
;
1202 tu
= kcalloc(1, sizeof(*tu
), GFP_KERNEL
);
1205 spin_lock_init(&tu
->qlock
);
1206 init_waitqueue_head(&tu
->qchange_sleep
);
1207 init_MUTEX(&tu
->tread_sem
);
1209 tu
->queue_size
= 128;
1210 tu
->queue
= (snd_timer_read_t
*)kmalloc(tu
->queue_size
* sizeof(snd_timer_read_t
), GFP_KERNEL
);
1211 if (tu
->queue
== NULL
) {
1215 file
->private_data
= tu
;
1219 static int snd_timer_user_release(struct inode
*inode
, struct file
*file
)
1221 snd_timer_user_t
*tu
;
1223 if (file
->private_data
) {
1224 tu
= file
->private_data
;
1225 file
->private_data
= NULL
;
1226 fasync_helper(-1, file
, 0, &tu
->fasync
);
1228 snd_timer_close(tu
->timeri
);
1236 static void snd_timer_user_zero_id(snd_timer_id_t
*id
)
1238 id
->dev_class
= SNDRV_TIMER_CLASS_NONE
;
1239 id
->dev_sclass
= SNDRV_TIMER_SCLASS_NONE
;
1245 static void snd_timer_user_copy_id(snd_timer_id_t
*id
, snd_timer_t
*timer
)
1247 id
->dev_class
= timer
->tmr_class
;
1248 id
->dev_sclass
= SNDRV_TIMER_SCLASS_NONE
;
1249 id
->card
= timer
->card
? timer
->card
->number
: -1;
1250 id
->device
= timer
->tmr_device
;
1251 id
->subdevice
= timer
->tmr_subdevice
;
1254 static int snd_timer_user_next_device(snd_timer_id_t __user
*_tid
)
1258 struct list_head
*p
;
1260 if (copy_from_user(&id
, _tid
, sizeof(id
)))
1262 down(®ister_mutex
);
1263 if (id
.dev_class
< 0) { /* first item */
1264 if (list_empty(&snd_timer_list
))
1265 snd_timer_user_zero_id(&id
);
1267 timer
= (snd_timer_t
*)list_entry(snd_timer_list
.next
, snd_timer_t
, device_list
);
1268 snd_timer_user_copy_id(&id
, timer
);
1271 switch (id
.dev_class
) {
1272 case SNDRV_TIMER_CLASS_GLOBAL
:
1273 id
.device
= id
.device
< 0 ? 0 : id
.device
+ 1;
1274 list_for_each(p
, &snd_timer_list
) {
1275 timer
= (snd_timer_t
*)list_entry(p
, snd_timer_t
, device_list
);
1276 if (timer
->tmr_class
> SNDRV_TIMER_CLASS_GLOBAL
) {
1277 snd_timer_user_copy_id(&id
, timer
);
1280 if (timer
->tmr_device
>= id
.device
) {
1281 snd_timer_user_copy_id(&id
, timer
);
1285 if (p
== &snd_timer_list
)
1286 snd_timer_user_zero_id(&id
);
1288 case SNDRV_TIMER_CLASS_CARD
:
1289 case SNDRV_TIMER_CLASS_PCM
:
1296 if (id
.device
< 0) {
1299 id
.subdevice
= id
.subdevice
< 0 ? 0 : id
.subdevice
+ 1;
1303 list_for_each(p
, &snd_timer_list
) {
1304 timer
= (snd_timer_t
*)list_entry(p
, snd_timer_t
, device_list
);
1305 if (timer
->tmr_class
> id
.dev_class
) {
1306 snd_timer_user_copy_id(&id
, timer
);
1309 if (timer
->tmr_class
< id
.dev_class
)
1311 if (timer
->card
->number
> id
.card
) {
1312 snd_timer_user_copy_id(&id
, timer
);
1315 if (timer
->card
->number
< id
.card
)
1317 if (timer
->tmr_device
> id
.device
) {
1318 snd_timer_user_copy_id(&id
, timer
);
1321 if (timer
->tmr_device
< id
.device
)
1323 if (timer
->tmr_subdevice
> id
.subdevice
) {
1324 snd_timer_user_copy_id(&id
, timer
);
1327 if (timer
->tmr_subdevice
< id
.subdevice
)
1329 snd_timer_user_copy_id(&id
, timer
);
1332 if (p
== &snd_timer_list
)
1333 snd_timer_user_zero_id(&id
);
1336 snd_timer_user_zero_id(&id
);
1339 up(®ister_mutex
);
1340 if (copy_to_user(_tid
, &id
, sizeof(*_tid
)))
1345 static int snd_timer_user_ginfo(struct file
*file
, snd_timer_ginfo_t __user
*_ginfo
)
1347 snd_timer_ginfo_t
*ginfo
;
1350 struct list_head
*p
;
1353 ginfo
= kmalloc(sizeof(*ginfo
), GFP_KERNEL
);
1356 if (copy_from_user(ginfo
, _ginfo
, sizeof(*ginfo
))) {
1361 memset(ginfo
, 0, sizeof(*ginfo
));
1363 down(®ister_mutex
);
1364 t
= snd_timer_find(&tid
);
1366 ginfo
->card
= t
->card
? t
->card
->number
: -1;
1367 if (t
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
1368 ginfo
->flags
|= SNDRV_TIMER_FLG_SLAVE
;
1369 strlcpy(ginfo
->id
, t
->id
, sizeof(ginfo
->id
));
1370 strlcpy(ginfo
->name
, t
->name
, sizeof(ginfo
->name
));
1371 ginfo
->resolution
= t
->hw
.resolution
;
1372 if (t
->hw
.resolution_min
> 0) {
1373 ginfo
->resolution_min
= t
->hw
.resolution_min
;
1374 ginfo
->resolution_max
= t
->hw
.resolution_max
;
1376 list_for_each(p
, &t
->open_list_head
) {
1382 up(®ister_mutex
);
1383 if (err
>= 0 && copy_to_user(_ginfo
, ginfo
, sizeof(*ginfo
)))
1389 static int snd_timer_user_gparams(struct file
*file
, snd_timer_gparams_t __user
*_gparams
)
1391 snd_timer_gparams_t gparams
;
1395 if (copy_from_user(&gparams
, _gparams
, sizeof(gparams
)))
1397 down(®ister_mutex
);
1398 t
= snd_timer_find(&gparams
.tid
);
1400 if (list_empty(&t
->open_list_head
)) {
1401 if (t
->hw
.set_period
)
1402 err
= t
->hw
.set_period(t
, gparams
.period_num
, gparams
.period_den
);
1411 up(®ister_mutex
);
1415 static int snd_timer_user_gstatus(struct file
*file
, snd_timer_gstatus_t __user
*_gstatus
)
1417 snd_timer_gstatus_t gstatus
;
1422 if (copy_from_user(&gstatus
, _gstatus
, sizeof(gstatus
)))
1425 memset(&gstatus
, 0, sizeof(gstatus
));
1427 down(®ister_mutex
);
1428 t
= snd_timer_find(&tid
);
1430 if (t
->hw
.c_resolution
)
1431 gstatus
.resolution
= t
->hw
.c_resolution(t
);
1433 gstatus
.resolution
= t
->hw
.resolution
;
1434 if (t
->hw
.precise_resolution
) {
1435 t
->hw
.precise_resolution(t
, &gstatus
.resolution_num
, &gstatus
.resolution_den
);
1437 gstatus
.resolution_num
= gstatus
.resolution
;
1438 gstatus
.resolution_den
= 1000000000uL;
1443 up(®ister_mutex
);
1444 if (err
>= 0 && copy_to_user(_gstatus
, &gstatus
, sizeof(gstatus
)))
1449 static int snd_timer_user_tselect(struct file
*file
, snd_timer_select_t __user
*_tselect
)
1451 snd_timer_user_t
*tu
;
1452 snd_timer_select_t tselect
;
1456 tu
= file
->private_data
;
1457 down(&tu
->tread_sem
);
1459 snd_timer_close(tu
->timeri
);
1462 if (copy_from_user(&tselect
, _tselect
, sizeof(tselect
))) {
1466 sprintf(str
, "application %i", current
->pid
);
1467 if (tselect
.id
.dev_class
!= SNDRV_TIMER_CLASS_SLAVE
)
1468 tselect
.id
.dev_sclass
= SNDRV_TIMER_SCLASS_APPLICATION
;
1469 if ((err
= snd_timer_open(&tu
->timeri
, str
, &tselect
.id
, current
->pid
)) < 0)
1477 tu
->tqueue
= (snd_timer_tread_t
*)kmalloc(tu
->queue_size
* sizeof(snd_timer_tread_t
), GFP_KERNEL
);
1478 if (tu
->tqueue
== NULL
)
1481 tu
->queue
= (snd_timer_read_t
*)kmalloc(tu
->queue_size
* sizeof(snd_timer_read_t
), GFP_KERNEL
);
1482 if (tu
->queue
== NULL
)
1487 snd_timer_close(tu
->timeri
);
1490 tu
->timeri
->flags
|= SNDRV_TIMER_IFLG_FAST
;
1491 tu
->timeri
->callback
= tu
->tread
? snd_timer_user_tinterrupt
: snd_timer_user_interrupt
;
1492 tu
->timeri
->ccallback
= snd_timer_user_ccallback
;
1493 tu
->timeri
->callback_data
= (void *)tu
;
1501 static int snd_timer_user_info(struct file
*file
, snd_timer_info_t __user
*_info
)
1503 snd_timer_user_t
*tu
;
1504 snd_timer_info_t
*info
;
1508 tu
= file
->private_data
;
1509 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1510 t
= tu
->timeri
->timer
;
1511 snd_assert(t
!= NULL
, return -ENXIO
);
1513 info
= kcalloc(1, sizeof(*info
), GFP_KERNEL
);
1516 info
->card
= t
->card
? t
->card
->number
: -1;
1517 if (t
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
1518 info
->flags
|= SNDRV_TIMER_FLG_SLAVE
;
1519 strlcpy(info
->id
, t
->id
, sizeof(info
->id
));
1520 strlcpy(info
->name
, t
->name
, sizeof(info
->name
));
1521 info
->resolution
= t
->hw
.resolution
;
1522 if (copy_to_user(_info
, info
, sizeof(*_info
)))
1528 static int snd_timer_user_params(struct file
*file
, snd_timer_params_t __user
*_params
)
1530 snd_timer_user_t
*tu
;
1531 snd_timer_params_t params
;
1533 snd_timer_read_t
*tr
;
1534 snd_timer_tread_t
*ttr
;
1537 tu
= file
->private_data
;
1538 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1539 t
= tu
->timeri
->timer
;
1540 snd_assert(t
!= NULL
, return -ENXIO
);
1541 if (copy_from_user(¶ms
, _params
, sizeof(params
)))
1543 if (!(t
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
) && params
.ticks
< 1) {
1547 if (params
.queue_size
> 0 && (params
.queue_size
< 32 || params
.queue_size
> 1024)) {
1551 if (params
.filter
& ~((1<<SNDRV_TIMER_EVENT_RESOLUTION
)|
1552 (1<<SNDRV_TIMER_EVENT_TICK
)|
1553 (1<<SNDRV_TIMER_EVENT_START
)|
1554 (1<<SNDRV_TIMER_EVENT_STOP
)|
1555 (1<<SNDRV_TIMER_EVENT_CONTINUE
)|
1556 (1<<SNDRV_TIMER_EVENT_PAUSE
)|
1557 (1<<SNDRV_TIMER_EVENT_MSTART
)|
1558 (1<<SNDRV_TIMER_EVENT_MSTOP
)|
1559 (1<<SNDRV_TIMER_EVENT_MCONTINUE
)|
1560 (1<<SNDRV_TIMER_EVENT_MPAUSE
))) {
1564 snd_timer_stop(tu
->timeri
);
1565 spin_lock_irq(&t
->lock
);
1566 tu
->timeri
->flags
&= ~(SNDRV_TIMER_IFLG_AUTO
|
1567 SNDRV_TIMER_IFLG_EXCLUSIVE
|
1568 SNDRV_TIMER_IFLG_EARLY_EVENT
);
1569 if (params
.flags
& SNDRV_TIMER_PSFLG_AUTO
)
1570 tu
->timeri
->flags
|= SNDRV_TIMER_IFLG_AUTO
;
1571 if (params
.flags
& SNDRV_TIMER_PSFLG_EXCLUSIVE
)
1572 tu
->timeri
->flags
|= SNDRV_TIMER_IFLG_EXCLUSIVE
;
1573 if (params
.flags
& SNDRV_TIMER_PSFLG_EARLY_EVENT
)
1574 tu
->timeri
->flags
|= SNDRV_TIMER_IFLG_EARLY_EVENT
;
1575 spin_unlock_irq(&t
->lock
);
1576 if (params
.queue_size
> 0 && (unsigned int)tu
->queue_size
!= params
.queue_size
) {
1578 ttr
= (snd_timer_tread_t
*)kmalloc(params
.queue_size
* sizeof(snd_timer_tread_t
), GFP_KERNEL
);
1581 tu
->queue_size
= params
.queue_size
;
1585 tr
= (snd_timer_read_t
*)kmalloc(params
.queue_size
* sizeof(snd_timer_read_t
), GFP_KERNEL
);
1588 tu
->queue_size
= params
.queue_size
;
1593 tu
->qhead
= tu
->qtail
= tu
->qused
= 0;
1594 if (tu
->timeri
->flags
& SNDRV_TIMER_IFLG_EARLY_EVENT
) {
1596 snd_timer_tread_t tread
;
1597 tread
.event
= SNDRV_TIMER_EVENT_EARLY
;
1598 tread
.tstamp
.tv_sec
= 0;
1599 tread
.tstamp
.tv_nsec
= 0;
1601 snd_timer_user_append_to_tqueue(tu
, &tread
);
1603 snd_timer_read_t
*r
= &tu
->queue
[0];
1611 tu
->filter
= params
.filter
;
1612 tu
->ticks
= params
.ticks
;
1615 if (copy_to_user(_params
, ¶ms
, sizeof(params
)))
1620 static int snd_timer_user_status(struct file
*file
, snd_timer_status_t __user
*_status
)
1622 snd_timer_user_t
*tu
;
1623 snd_timer_status_t status
;
1625 tu
= file
->private_data
;
1626 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1627 memset(&status
, 0, sizeof(status
));
1628 status
.tstamp
= tu
->tstamp
;
1629 status
.resolution
= snd_timer_resolution(tu
->timeri
);
1630 status
.lost
= tu
->timeri
->lost
;
1631 status
.overrun
= tu
->overrun
;
1632 spin_lock_irq(&tu
->qlock
);
1633 status
.queue
= tu
->qused
;
1634 spin_unlock_irq(&tu
->qlock
);
1635 if (copy_to_user(_status
, &status
, sizeof(status
)))
1640 static int snd_timer_user_start(struct file
*file
)
1643 snd_timer_user_t
*tu
;
1645 tu
= file
->private_data
;
1646 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1647 snd_timer_stop(tu
->timeri
);
1648 tu
->timeri
->lost
= 0;
1649 tu
->last_resolution
= 0;
1650 return (err
= snd_timer_start(tu
->timeri
, tu
->ticks
)) < 0 ? err
: 0;
1653 static int snd_timer_user_stop(struct file
*file
)
1656 snd_timer_user_t
*tu
;
1658 tu
= file
->private_data
;
1659 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1660 return (err
= snd_timer_stop(tu
->timeri
)) < 0 ? err
: 0;
1663 static int snd_timer_user_continue(struct file
*file
)
1666 snd_timer_user_t
*tu
;
1668 tu
= file
->private_data
;
1669 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1670 tu
->timeri
->lost
= 0;
1671 return (err
= snd_timer_continue(tu
->timeri
)) < 0 ? err
: 0;
1674 static int snd_timer_user_pause(struct file
*file
)
1677 snd_timer_user_t
*tu
;
1679 tu
= file
->private_data
;
1680 snd_assert(tu
->timeri
!= NULL
, return -ENXIO
);
1681 return (err
= snd_timer_pause(tu
->timeri
)) < 0 ? err
: 0;
1685 SNDRV_TIMER_IOCTL_START_OLD
= _IO('T', 0x20),
1686 SNDRV_TIMER_IOCTL_STOP_OLD
= _IO('T', 0x21),
1687 SNDRV_TIMER_IOCTL_CONTINUE_OLD
= _IO('T', 0x22),
1688 SNDRV_TIMER_IOCTL_PAUSE_OLD
= _IO('T', 0x23),
1691 static long snd_timer_user_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
1693 snd_timer_user_t
*tu
;
1694 void __user
*argp
= (void __user
*)arg
;
1695 int __user
*p
= argp
;
1697 tu
= file
->private_data
;
1699 case SNDRV_TIMER_IOCTL_PVERSION
:
1700 return put_user(SNDRV_TIMER_VERSION
, p
) ? -EFAULT
: 0;
1701 case SNDRV_TIMER_IOCTL_NEXT_DEVICE
:
1702 return snd_timer_user_next_device(argp
);
1703 case SNDRV_TIMER_IOCTL_TREAD
:
1707 down(&tu
->tread_sem
);
1708 if (tu
->timeri
) { /* too late */
1712 if (get_user(xarg
, p
)) {
1716 tu
->tread
= xarg
? 1 : 0;
1720 case SNDRV_TIMER_IOCTL_GINFO
:
1721 return snd_timer_user_ginfo(file
, argp
);
1722 case SNDRV_TIMER_IOCTL_GPARAMS
:
1723 return snd_timer_user_gparams(file
, argp
);
1724 case SNDRV_TIMER_IOCTL_GSTATUS
:
1725 return snd_timer_user_gstatus(file
, argp
);
1726 case SNDRV_TIMER_IOCTL_SELECT
:
1727 return snd_timer_user_tselect(file
, argp
);
1728 case SNDRV_TIMER_IOCTL_INFO
:
1729 return snd_timer_user_info(file
, argp
);
1730 case SNDRV_TIMER_IOCTL_PARAMS
:
1731 return snd_timer_user_params(file
, argp
);
1732 case SNDRV_TIMER_IOCTL_STATUS
:
1733 return snd_timer_user_status(file
, argp
);
1734 case SNDRV_TIMER_IOCTL_START
:
1735 case SNDRV_TIMER_IOCTL_START_OLD
:
1736 return snd_timer_user_start(file
);
1737 case SNDRV_TIMER_IOCTL_STOP
:
1738 case SNDRV_TIMER_IOCTL_STOP_OLD
:
1739 return snd_timer_user_stop(file
);
1740 case SNDRV_TIMER_IOCTL_CONTINUE
:
1741 case SNDRV_TIMER_IOCTL_CONTINUE_OLD
:
1742 return snd_timer_user_continue(file
);
1743 case SNDRV_TIMER_IOCTL_PAUSE
:
1744 case SNDRV_TIMER_IOCTL_PAUSE_OLD
:
1745 return snd_timer_user_pause(file
);
1750 static int snd_timer_user_fasync(int fd
, struct file
* file
, int on
)
1752 snd_timer_user_t
*tu
;
1755 tu
= file
->private_data
;
1756 err
= fasync_helper(fd
, file
, on
, &tu
->fasync
);
1762 static ssize_t
snd_timer_user_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*offset
)
1764 snd_timer_user_t
*tu
;
1765 long result
= 0, unit
;
1768 tu
= file
->private_data
;
1769 unit
= tu
->tread
? sizeof(snd_timer_tread_t
) : sizeof(snd_timer_read_t
);
1770 spin_lock_irq(&tu
->qlock
);
1771 while ((long)count
- result
>= unit
) {
1772 while (!tu
->qused
) {
1775 if ((file
->f_flags
& O_NONBLOCK
) != 0 || result
> 0) {
1780 set_current_state(TASK_INTERRUPTIBLE
);
1781 init_waitqueue_entry(&wait
, current
);
1782 add_wait_queue(&tu
->qchange_sleep
, &wait
);
1784 spin_unlock_irq(&tu
->qlock
);
1786 spin_lock_irq(&tu
->qlock
);
1788 remove_wait_queue(&tu
->qchange_sleep
, &wait
);
1790 if (signal_pending(current
)) {
1796 spin_unlock_irq(&tu
->qlock
);
1801 if (copy_to_user(buffer
, &tu
->tqueue
[tu
->qhead
++], sizeof(snd_timer_tread_t
))) {
1806 if (copy_to_user(buffer
, &tu
->queue
[tu
->qhead
++], sizeof(snd_timer_read_t
))) {
1812 tu
->qhead
%= tu
->queue_size
;
1817 spin_lock_irq(&tu
->qlock
);
1820 spin_unlock_irq(&tu
->qlock
);
1822 return result
> 0 ? result
: err
;
1825 static unsigned int snd_timer_user_poll(struct file
*file
, poll_table
* wait
)
1828 snd_timer_user_t
*tu
;
1830 tu
= file
->private_data
;
1832 poll_wait(file
, &tu
->qchange_sleep
, wait
);
1836 mask
|= POLLIN
| POLLRDNORM
;
1841 #ifdef CONFIG_COMPAT
1842 #include "timer_compat.c"
1844 #define snd_timer_user_ioctl_compat NULL
1847 static struct file_operations snd_timer_f_ops
=
1849 .owner
= THIS_MODULE
,
1850 .read
= snd_timer_user_read
,
1851 .open
= snd_timer_user_open
,
1852 .release
= snd_timer_user_release
,
1853 .poll
= snd_timer_user_poll
,
1854 .unlocked_ioctl
= snd_timer_user_ioctl
,
1855 .compat_ioctl
= snd_timer_user_ioctl_compat
,
1856 .fasync
= snd_timer_user_fasync
,
1859 static snd_minor_t snd_timer_reg
=
1862 .f_ops
= &snd_timer_f_ops
,
1869 static snd_info_entry_t
*snd_timer_proc_entry
= NULL
;
1871 static int __init
alsa_timer_init(void)
1874 snd_info_entry_t
*entry
;
1876 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
1877 snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS
, SNDRV_CARDS
- 1, "system timer");
1879 if ((entry
= snd_info_create_module_entry(THIS_MODULE
, "timers", NULL
)) != NULL
) {
1880 entry
->c
.text
.read_size
= SNDRV_TIMER_DEVICES
* 128;
1881 entry
->c
.text
.read
= snd_timer_proc_read
;
1882 if (snd_info_register(entry
) < 0) {
1883 snd_info_free_entry(entry
);
1887 snd_timer_proc_entry
= entry
;
1888 if ((err
= snd_timer_register_system()) < 0)
1889 snd_printk(KERN_ERR
"unable to register system timer (%i)\n", err
);
1890 if ((err
= snd_register_device(SNDRV_DEVICE_TYPE_TIMER
,
1891 NULL
, 0, &snd_timer_reg
, "timer"))<0)
1892 snd_printk(KERN_ERR
"unable to register timer device (%i)\n", err
);
1896 static void __exit
alsa_timer_exit(void)
1898 struct list_head
*p
, *n
;
1900 snd_unregister_device(SNDRV_DEVICE_TYPE_TIMER
, NULL
, 0);
1901 /* unregister the system timer */
1902 list_for_each_safe(p
, n
, &snd_timer_list
) {
1903 snd_timer_t
*timer
= (snd_timer_t
*)list_entry(p
, snd_timer_t
, device_list
);
1904 snd_timer_unregister(timer
);
1906 if (snd_timer_proc_entry
) {
1907 snd_info_unregister(snd_timer_proc_entry
);
1908 snd_timer_proc_entry
= NULL
;
1910 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
1911 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS
, SNDRV_CARDS
- 1);
1915 module_init(alsa_timer_init
)
1916 module_exit(alsa_timer_exit
)
1918 EXPORT_SYMBOL(snd_timer_open
);
1919 EXPORT_SYMBOL(snd_timer_close
);
1920 EXPORT_SYMBOL(snd_timer_resolution
);
1921 EXPORT_SYMBOL(snd_timer_start
);
1922 EXPORT_SYMBOL(snd_timer_stop
);
1923 EXPORT_SYMBOL(snd_timer_continue
);
1924 EXPORT_SYMBOL(snd_timer_pause
);
1925 EXPORT_SYMBOL(snd_timer_new
);
1926 EXPORT_SYMBOL(snd_timer_notify
);
1927 EXPORT_SYMBOL(snd_timer_global_new
);
1928 EXPORT_SYMBOL(snd_timer_global_free
);
1929 EXPORT_SYMBOL(snd_timer_global_register
);
1930 EXPORT_SYMBOL(snd_timer_global_unregister
);
1931 EXPORT_SYMBOL(snd_timer_interrupt
);