2 * Timers abstract layer
3 * Copyright (c) by Jaroslav Kysela <perex@perex.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 <linux/delay.h>
23 #include <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/time.h>
26 #include <linux/mutex.h>
27 #include <linux/device.h>
28 #include <linux/module.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 #if IS_ENABLED(CONFIG_SND_HRTIMER)
39 #define DEFAULT_TIMER_LIMIT 4
41 #define DEFAULT_TIMER_LIMIT 1
44 static int timer_limit
= DEFAULT_TIMER_LIMIT
;
45 static int timer_tstamp_monotonic
= 1;
46 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>");
47 MODULE_DESCRIPTION("ALSA timer interface");
48 MODULE_LICENSE("GPL");
49 module_param(timer_limit
, int, 0444);
50 MODULE_PARM_DESC(timer_limit
, "Maximum global timers in system.");
51 module_param(timer_tstamp_monotonic
, int, 0444);
52 MODULE_PARM_DESC(timer_tstamp_monotonic
, "Use posix monotonic clock source for timestamps (default).");
54 MODULE_ALIAS_CHARDEV(CONFIG_SND_MAJOR
, SNDRV_MINOR_TIMER
);
55 MODULE_ALIAS("devname:snd/timer");
57 struct snd_timer_user
{
58 struct snd_timer_instance
*timeri
;
59 int tread
; /* enhanced read with timestamps and events */
61 unsigned long overrun
;
67 struct snd_timer_read
*queue
;
68 struct snd_timer_tread
*tqueue
;
70 unsigned long last_resolution
;
72 struct timespec tstamp
; /* trigger tstamp */
73 wait_queue_head_t qchange_sleep
;
74 struct fasync_struct
*fasync
;
75 struct mutex ioctl_lock
;
79 static LIST_HEAD(snd_timer_list
);
81 /* list of slave instances */
82 static LIST_HEAD(snd_timer_slave_list
);
84 /* lock for slave active lists */
85 static DEFINE_SPINLOCK(slave_active_lock
);
87 static DEFINE_MUTEX(register_mutex
);
89 static int snd_timer_free(struct snd_timer
*timer
);
90 static int snd_timer_dev_free(struct snd_device
*device
);
91 static int snd_timer_dev_register(struct snd_device
*device
);
92 static int snd_timer_dev_disconnect(struct snd_device
*device
);
94 static void snd_timer_reschedule(struct snd_timer
* timer
, unsigned long ticks_left
);
97 * create a timer instance with the given owner string.
98 * when timer is not NULL, increments the module counter
100 static struct snd_timer_instance
*snd_timer_instance_new(char *owner
,
101 struct snd_timer
*timer
)
103 struct snd_timer_instance
*timeri
;
104 timeri
= kzalloc(sizeof(*timeri
), GFP_KERNEL
);
107 timeri
->owner
= kstrdup(owner
, GFP_KERNEL
);
108 if (! timeri
->owner
) {
112 INIT_LIST_HEAD(&timeri
->open_list
);
113 INIT_LIST_HEAD(&timeri
->active_list
);
114 INIT_LIST_HEAD(&timeri
->ack_list
);
115 INIT_LIST_HEAD(&timeri
->slave_list_head
);
116 INIT_LIST_HEAD(&timeri
->slave_active_head
);
118 timeri
->timer
= timer
;
119 if (timer
&& !try_module_get(timer
->module
)) {
120 kfree(timeri
->owner
);
129 * find a timer instance from the given timer id
131 static struct snd_timer
*snd_timer_find(struct snd_timer_id
*tid
)
133 struct snd_timer
*timer
= NULL
;
135 list_for_each_entry(timer
, &snd_timer_list
, device_list
) {
136 if (timer
->tmr_class
!= tid
->dev_class
)
138 if ((timer
->tmr_class
== SNDRV_TIMER_CLASS_CARD
||
139 timer
->tmr_class
== SNDRV_TIMER_CLASS_PCM
) &&
140 (timer
->card
== NULL
||
141 timer
->card
->number
!= tid
->card
))
143 if (timer
->tmr_device
!= tid
->device
)
145 if (timer
->tmr_subdevice
!= tid
->subdevice
)
152 #ifdef CONFIG_MODULES
154 static void snd_timer_request(struct snd_timer_id
*tid
)
156 switch (tid
->dev_class
) {
157 case SNDRV_TIMER_CLASS_GLOBAL
:
158 if (tid
->device
< timer_limit
)
159 request_module("snd-timer-%i", tid
->device
);
161 case SNDRV_TIMER_CLASS_CARD
:
162 case SNDRV_TIMER_CLASS_PCM
:
163 if (tid
->card
< snd_ecards_limit
)
164 request_module("snd-card-%i", tid
->card
);
174 * look for a master instance matching with the slave id of the given slave.
175 * when found, relink the open_link of the slave.
177 * call this with register_mutex down.
179 static void snd_timer_check_slave(struct snd_timer_instance
*slave
)
181 struct snd_timer
*timer
;
182 struct snd_timer_instance
*master
;
184 /* FIXME: it's really dumb to look up all entries.. */
185 list_for_each_entry(timer
, &snd_timer_list
, device_list
) {
186 list_for_each_entry(master
, &timer
->open_list_head
, open_list
) {
187 if (slave
->slave_class
== master
->slave_class
&&
188 slave
->slave_id
== master
->slave_id
) {
189 list_move_tail(&slave
->open_list
,
190 &master
->slave_list_head
);
191 spin_lock_irq(&slave_active_lock
);
192 slave
->master
= master
;
193 slave
->timer
= master
->timer
;
194 spin_unlock_irq(&slave_active_lock
);
202 * look for slave instances matching with the slave id of the given master.
203 * when found, relink the open_link of slaves.
205 * call this with register_mutex down.
207 static void snd_timer_check_master(struct snd_timer_instance
*master
)
209 struct snd_timer_instance
*slave
, *tmp
;
211 /* check all pending slaves */
212 list_for_each_entry_safe(slave
, tmp
, &snd_timer_slave_list
, open_list
) {
213 if (slave
->slave_class
== master
->slave_class
&&
214 slave
->slave_id
== master
->slave_id
) {
215 list_move_tail(&slave
->open_list
, &master
->slave_list_head
);
216 spin_lock_irq(&slave_active_lock
);
217 spin_lock(&master
->timer
->lock
);
218 slave
->master
= master
;
219 slave
->timer
= master
->timer
;
220 if (slave
->flags
& SNDRV_TIMER_IFLG_RUNNING
)
221 list_add_tail(&slave
->active_list
,
222 &master
->slave_active_head
);
223 spin_unlock(&master
->timer
->lock
);
224 spin_unlock_irq(&slave_active_lock
);
230 * open a timer instance
231 * when opening a master, the slave id must be here given.
233 int snd_timer_open(struct snd_timer_instance
**ti
,
234 char *owner
, struct snd_timer_id
*tid
,
235 unsigned int slave_id
)
237 struct snd_timer
*timer
;
238 struct snd_timer_instance
*timeri
= NULL
;
240 if (tid
->dev_class
== SNDRV_TIMER_CLASS_SLAVE
) {
241 /* open a slave instance */
242 if (tid
->dev_sclass
<= SNDRV_TIMER_SCLASS_NONE
||
243 tid
->dev_sclass
> SNDRV_TIMER_SCLASS_OSS_SEQUENCER
) {
244 pr_debug("ALSA: timer: invalid slave class %i\n",
248 mutex_lock(®ister_mutex
);
249 timeri
= snd_timer_instance_new(owner
, NULL
);
251 mutex_unlock(®ister_mutex
);
254 timeri
->slave_class
= tid
->dev_sclass
;
255 timeri
->slave_id
= tid
->device
;
256 timeri
->flags
|= SNDRV_TIMER_IFLG_SLAVE
;
257 list_add_tail(&timeri
->open_list
, &snd_timer_slave_list
);
258 snd_timer_check_slave(timeri
);
259 mutex_unlock(®ister_mutex
);
264 /* open a master instance */
265 mutex_lock(®ister_mutex
);
266 timer
= snd_timer_find(tid
);
267 #ifdef CONFIG_MODULES
269 mutex_unlock(®ister_mutex
);
270 snd_timer_request(tid
);
271 mutex_lock(®ister_mutex
);
272 timer
= snd_timer_find(tid
);
276 mutex_unlock(®ister_mutex
);
279 if (!list_empty(&timer
->open_list_head
)) {
280 timeri
= list_entry(timer
->open_list_head
.next
,
281 struct snd_timer_instance
, open_list
);
282 if (timeri
->flags
& SNDRV_TIMER_IFLG_EXCLUSIVE
) {
283 mutex_unlock(®ister_mutex
);
287 timeri
= snd_timer_instance_new(owner
, timer
);
289 mutex_unlock(®ister_mutex
);
292 /* take a card refcount for safe disconnection */
294 get_device(&timer
->card
->card_dev
);
295 timeri
->slave_class
= tid
->dev_sclass
;
296 timeri
->slave_id
= slave_id
;
297 if (list_empty(&timer
->open_list_head
) && timer
->hw
.open
)
298 timer
->hw
.open(timer
);
299 list_add_tail(&timeri
->open_list
, &timer
->open_list_head
);
300 snd_timer_check_master(timeri
);
301 mutex_unlock(®ister_mutex
);
307 * close a timer instance
309 int snd_timer_close(struct snd_timer_instance
*timeri
)
311 struct snd_timer
*timer
= NULL
;
312 struct snd_timer_instance
*slave
, *tmp
;
314 if (snd_BUG_ON(!timeri
))
317 mutex_lock(®ister_mutex
);
318 list_del(&timeri
->open_list
);
320 /* force to stop the timer */
321 snd_timer_stop(timeri
);
323 timer
= timeri
->timer
;
325 /* wait, until the active callback is finished */
326 spin_lock_irq(&timer
->lock
);
327 while (timeri
->flags
& SNDRV_TIMER_IFLG_CALLBACK
) {
328 spin_unlock_irq(&timer
->lock
);
330 spin_lock_irq(&timer
->lock
);
332 spin_unlock_irq(&timer
->lock
);
334 /* remove slave links */
335 spin_lock_irq(&slave_active_lock
);
336 spin_lock(&timer
->lock
);
337 list_for_each_entry_safe(slave
, tmp
, &timeri
->slave_list_head
,
339 list_move_tail(&slave
->open_list
, &snd_timer_slave_list
);
340 slave
->master
= NULL
;
342 list_del_init(&slave
->ack_list
);
343 list_del_init(&slave
->active_list
);
345 spin_unlock(&timer
->lock
);
346 spin_unlock_irq(&slave_active_lock
);
348 /* slave doesn't need to release timer resources below */
349 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
)
353 if (timeri
->private_free
)
354 timeri
->private_free(timeri
);
355 kfree(timeri
->owner
);
359 if (list_empty(&timer
->open_list_head
) && timer
->hw
.close
)
360 timer
->hw
.close(timer
);
361 /* release a card refcount for safe disconnection */
363 put_device(&timer
->card
->card_dev
);
364 module_put(timer
->module
);
367 mutex_unlock(®ister_mutex
);
371 unsigned long snd_timer_resolution(struct snd_timer_instance
*timeri
)
373 struct snd_timer
* timer
;
377 if ((timer
= timeri
->timer
) != NULL
) {
378 if (timer
->hw
.c_resolution
)
379 return timer
->hw
.c_resolution(timer
);
380 return timer
->hw
.resolution
;
385 static void snd_timer_notify1(struct snd_timer_instance
*ti
, int event
)
387 struct snd_timer
*timer
;
388 unsigned long resolution
= 0;
389 struct snd_timer_instance
*ts
;
390 struct timespec tstamp
;
392 if (timer_tstamp_monotonic
)
393 ktime_get_ts(&tstamp
);
395 getnstimeofday(&tstamp
);
396 if (snd_BUG_ON(event
< SNDRV_TIMER_EVENT_START
||
397 event
> SNDRV_TIMER_EVENT_PAUSE
))
399 if (event
== SNDRV_TIMER_EVENT_START
||
400 event
== SNDRV_TIMER_EVENT_CONTINUE
)
401 resolution
= snd_timer_resolution(ti
);
403 ti
->ccallback(ti
, event
, &tstamp
, resolution
);
404 if (ti
->flags
& SNDRV_TIMER_IFLG_SLAVE
)
409 if (timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
411 list_for_each_entry(ts
, &ti
->slave_active_head
, active_list
)
413 ts
->ccallback(ts
, event
+ 100, &tstamp
, resolution
);
416 /* start/continue a master timer */
417 static int snd_timer_start1(struct snd_timer_instance
*timeri
,
418 bool start
, unsigned long ticks
)
420 struct snd_timer
*timer
;
424 timer
= timeri
->timer
;
428 spin_lock_irqsave(&timer
->lock
, flags
);
429 if (timer
->card
&& timer
->card
->shutdown
) {
433 if (timeri
->flags
& (SNDRV_TIMER_IFLG_RUNNING
|
434 SNDRV_TIMER_IFLG_START
)) {
440 timeri
->ticks
= timeri
->cticks
= ticks
;
441 else if (!timeri
->cticks
)
445 list_move_tail(&timeri
->active_list
, &timer
->active_list_head
);
446 if (timer
->running
) {
447 if (timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
449 timer
->flags
|= SNDRV_TIMER_FLG_RESCHED
;
450 timeri
->flags
|= SNDRV_TIMER_IFLG_START
;
451 result
= 1; /* delayed start */
454 timer
->sticks
= ticks
;
455 timer
->hw
.start(timer
);
458 timeri
->flags
|= SNDRV_TIMER_IFLG_RUNNING
;
461 snd_timer_notify1(timeri
, start
? SNDRV_TIMER_EVENT_START
:
462 SNDRV_TIMER_EVENT_CONTINUE
);
464 spin_unlock_irqrestore(&timer
->lock
, flags
);
468 /* start/continue a slave timer */
469 static int snd_timer_start_slave(struct snd_timer_instance
*timeri
,
474 spin_lock_irqsave(&slave_active_lock
, flags
);
475 if (timeri
->flags
& SNDRV_TIMER_IFLG_RUNNING
) {
476 spin_unlock_irqrestore(&slave_active_lock
, flags
);
479 timeri
->flags
|= SNDRV_TIMER_IFLG_RUNNING
;
480 if (timeri
->master
&& timeri
->timer
) {
481 spin_lock(&timeri
->timer
->lock
);
482 list_add_tail(&timeri
->active_list
,
483 &timeri
->master
->slave_active_head
);
484 snd_timer_notify1(timeri
, start
? SNDRV_TIMER_EVENT_START
:
485 SNDRV_TIMER_EVENT_CONTINUE
);
486 spin_unlock(&timeri
->timer
->lock
);
488 spin_unlock_irqrestore(&slave_active_lock
, flags
);
489 return 1; /* delayed start */
492 /* stop/pause a master timer */
493 static int snd_timer_stop1(struct snd_timer_instance
*timeri
, bool stop
)
495 struct snd_timer
*timer
;
499 timer
= timeri
->timer
;
502 spin_lock_irqsave(&timer
->lock
, flags
);
503 if (!(timeri
->flags
& (SNDRV_TIMER_IFLG_RUNNING
|
504 SNDRV_TIMER_IFLG_START
))) {
508 list_del_init(&timeri
->ack_list
);
509 list_del_init(&timeri
->active_list
);
510 if (timer
->card
&& timer
->card
->shutdown
)
513 timeri
->cticks
= timeri
->ticks
;
516 if ((timeri
->flags
& SNDRV_TIMER_IFLG_RUNNING
) &&
517 !(--timer
->running
)) {
518 timer
->hw
.stop(timer
);
519 if (timer
->flags
& SNDRV_TIMER_FLG_RESCHED
) {
520 timer
->flags
&= ~SNDRV_TIMER_FLG_RESCHED
;
521 snd_timer_reschedule(timer
, 0);
522 if (timer
->flags
& SNDRV_TIMER_FLG_CHANGE
) {
523 timer
->flags
&= ~SNDRV_TIMER_FLG_CHANGE
;
524 timer
->hw
.start(timer
);
528 timeri
->flags
&= ~(SNDRV_TIMER_IFLG_RUNNING
| SNDRV_TIMER_IFLG_START
);
529 snd_timer_notify1(timeri
, stop
? SNDRV_TIMER_EVENT_STOP
:
530 SNDRV_TIMER_EVENT_CONTINUE
);
532 spin_unlock_irqrestore(&timer
->lock
, flags
);
536 /* stop/pause a slave timer */
537 static int snd_timer_stop_slave(struct snd_timer_instance
*timeri
, bool stop
)
541 spin_lock_irqsave(&slave_active_lock
, flags
);
542 if (!(timeri
->flags
& SNDRV_TIMER_IFLG_RUNNING
)) {
543 spin_unlock_irqrestore(&slave_active_lock
, flags
);
546 timeri
->flags
&= ~SNDRV_TIMER_IFLG_RUNNING
;
548 spin_lock(&timeri
->timer
->lock
);
549 list_del_init(&timeri
->ack_list
);
550 list_del_init(&timeri
->active_list
);
551 snd_timer_notify1(timeri
, stop
? SNDRV_TIMER_EVENT_STOP
:
552 SNDRV_TIMER_EVENT_CONTINUE
);
553 spin_unlock(&timeri
->timer
->lock
);
555 spin_unlock_irqrestore(&slave_active_lock
, flags
);
560 * start the timer instance
562 int snd_timer_start(struct snd_timer_instance
*timeri
, unsigned int ticks
)
564 if (timeri
== NULL
|| ticks
< 1)
566 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
)
567 return snd_timer_start_slave(timeri
, true);
569 return snd_timer_start1(timeri
, true, ticks
);
573 * stop the timer instance.
575 * do not call this from the timer callback!
577 int snd_timer_stop(struct snd_timer_instance
*timeri
)
579 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
)
580 return snd_timer_stop_slave(timeri
, true);
582 return snd_timer_stop1(timeri
, true);
586 * start again.. the tick is kept.
588 int snd_timer_continue(struct snd_timer_instance
*timeri
)
590 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
)
591 return snd_timer_start_slave(timeri
, false);
593 return snd_timer_start1(timeri
, false, 0);
597 * pause.. remember the ticks left
599 int snd_timer_pause(struct snd_timer_instance
* timeri
)
601 if (timeri
->flags
& SNDRV_TIMER_IFLG_SLAVE
)
602 return snd_timer_stop_slave(timeri
, false);
604 return snd_timer_stop1(timeri
, false);
608 * reschedule the timer
610 * start pending instances and check the scheduling ticks.
611 * when the scheduling ticks is changed set CHANGE flag to reprogram the timer.
613 static void snd_timer_reschedule(struct snd_timer
* timer
, unsigned long ticks_left
)
615 struct snd_timer_instance
*ti
;
616 unsigned long ticks
= ~0UL;
618 list_for_each_entry(ti
, &timer
->active_list_head
, active_list
) {
619 if (ti
->flags
& SNDRV_TIMER_IFLG_START
) {
620 ti
->flags
&= ~SNDRV_TIMER_IFLG_START
;
621 ti
->flags
|= SNDRV_TIMER_IFLG_RUNNING
;
624 if (ti
->flags
& SNDRV_TIMER_IFLG_RUNNING
) {
625 if (ticks
> ti
->cticks
)
630 timer
->flags
&= ~SNDRV_TIMER_FLG_RESCHED
;
633 if (ticks
> timer
->hw
.ticks
)
634 ticks
= timer
->hw
.ticks
;
635 if (ticks_left
!= ticks
)
636 timer
->flags
|= SNDRV_TIMER_FLG_CHANGE
;
637 timer
->sticks
= ticks
;
644 static void snd_timer_tasklet(unsigned long arg
)
646 struct snd_timer
*timer
= (struct snd_timer
*) arg
;
647 struct snd_timer_instance
*ti
;
649 unsigned long resolution
, ticks
;
652 if (timer
->card
&& timer
->card
->shutdown
)
655 spin_lock_irqsave(&timer
->lock
, flags
);
656 /* now process all callbacks */
657 while (!list_empty(&timer
->sack_list_head
)) {
658 p
= timer
->sack_list_head
.next
; /* get first item */
659 ti
= list_entry(p
, struct snd_timer_instance
, ack_list
);
661 /* remove from ack_list and make empty */
666 resolution
= ti
->resolution
;
668 ti
->flags
|= SNDRV_TIMER_IFLG_CALLBACK
;
669 spin_unlock(&timer
->lock
);
671 ti
->callback(ti
, resolution
, ticks
);
672 spin_lock(&timer
->lock
);
673 ti
->flags
&= ~SNDRV_TIMER_IFLG_CALLBACK
;
675 spin_unlock_irqrestore(&timer
->lock
, flags
);
681 * ticks_left is usually equal to timer->sticks.
684 void snd_timer_interrupt(struct snd_timer
* timer
, unsigned long ticks_left
)
686 struct snd_timer_instance
*ti
, *ts
, *tmp
;
687 unsigned long resolution
, ticks
;
688 struct list_head
*p
, *ack_list_head
;
695 if (timer
->card
&& timer
->card
->shutdown
)
698 spin_lock_irqsave(&timer
->lock
, flags
);
700 /* remember the current resolution */
701 if (timer
->hw
.c_resolution
)
702 resolution
= timer
->hw
.c_resolution(timer
);
704 resolution
= timer
->hw
.resolution
;
706 /* loop for all active instances
707 * Here we cannot use list_for_each_entry because the active_list of a
708 * processed instance is relinked to done_list_head before the callback
711 list_for_each_entry_safe(ti
, tmp
, &timer
->active_list_head
,
713 if (!(ti
->flags
& SNDRV_TIMER_IFLG_RUNNING
))
715 ti
->pticks
+= ticks_left
;
716 ti
->resolution
= resolution
;
717 if (ti
->cticks
< ticks_left
)
720 ti
->cticks
-= ticks_left
;
721 if (ti
->cticks
) /* not expired */
723 if (ti
->flags
& SNDRV_TIMER_IFLG_AUTO
) {
724 ti
->cticks
= ti
->ticks
;
726 ti
->flags
&= ~SNDRV_TIMER_IFLG_RUNNING
;
728 list_del_init(&ti
->active_list
);
730 if ((timer
->hw
.flags
& SNDRV_TIMER_HW_TASKLET
) ||
731 (ti
->flags
& SNDRV_TIMER_IFLG_FAST
))
732 ack_list_head
= &timer
->ack_list_head
;
734 ack_list_head
= &timer
->sack_list_head
;
735 if (list_empty(&ti
->ack_list
))
736 list_add_tail(&ti
->ack_list
, ack_list_head
);
737 list_for_each_entry(ts
, &ti
->slave_active_head
, active_list
) {
738 ts
->pticks
= ti
->pticks
;
739 ts
->resolution
= resolution
;
740 if (list_empty(&ts
->ack_list
))
741 list_add_tail(&ts
->ack_list
, ack_list_head
);
744 if (timer
->flags
& SNDRV_TIMER_FLG_RESCHED
)
745 snd_timer_reschedule(timer
, timer
->sticks
);
746 if (timer
->running
) {
747 if (timer
->hw
.flags
& SNDRV_TIMER_HW_STOP
) {
748 timer
->hw
.stop(timer
);
749 timer
->flags
|= SNDRV_TIMER_FLG_CHANGE
;
751 if (!(timer
->hw
.flags
& SNDRV_TIMER_HW_AUTO
) ||
752 (timer
->flags
& SNDRV_TIMER_FLG_CHANGE
)) {
754 timer
->flags
&= ~SNDRV_TIMER_FLG_CHANGE
;
755 timer
->hw
.start(timer
);
758 timer
->hw
.stop(timer
);
761 /* now process all fast callbacks */
762 while (!list_empty(&timer
->ack_list_head
)) {
763 p
= timer
->ack_list_head
.next
; /* get first item */
764 ti
= list_entry(p
, struct snd_timer_instance
, ack_list
);
766 /* remove from ack_list and make empty */
772 ti
->flags
|= SNDRV_TIMER_IFLG_CALLBACK
;
773 spin_unlock(&timer
->lock
);
775 ti
->callback(ti
, resolution
, ticks
);
776 spin_lock(&timer
->lock
);
777 ti
->flags
&= ~SNDRV_TIMER_IFLG_CALLBACK
;
780 /* do we have any slow callbacks? */
781 use_tasklet
= !list_empty(&timer
->sack_list_head
);
782 spin_unlock_irqrestore(&timer
->lock
, flags
);
785 tasklet_schedule(&timer
->task_queue
);
792 int snd_timer_new(struct snd_card
*card
, char *id
, struct snd_timer_id
*tid
,
793 struct snd_timer
**rtimer
)
795 struct snd_timer
*timer
;
797 static struct snd_device_ops ops
= {
798 .dev_free
= snd_timer_dev_free
,
799 .dev_register
= snd_timer_dev_register
,
800 .dev_disconnect
= snd_timer_dev_disconnect
,
803 if (snd_BUG_ON(!tid
))
807 timer
= kzalloc(sizeof(*timer
), GFP_KERNEL
);
810 timer
->tmr_class
= tid
->dev_class
;
812 timer
->tmr_device
= tid
->device
;
813 timer
->tmr_subdevice
= tid
->subdevice
;
815 strlcpy(timer
->id
, id
, sizeof(timer
->id
));
816 INIT_LIST_HEAD(&timer
->device_list
);
817 INIT_LIST_HEAD(&timer
->open_list_head
);
818 INIT_LIST_HEAD(&timer
->active_list_head
);
819 INIT_LIST_HEAD(&timer
->ack_list_head
);
820 INIT_LIST_HEAD(&timer
->sack_list_head
);
821 spin_lock_init(&timer
->lock
);
822 tasklet_init(&timer
->task_queue
, snd_timer_tasklet
,
823 (unsigned long)timer
);
825 timer
->module
= card
->module
;
826 err
= snd_device_new(card
, SNDRV_DEV_TIMER
, timer
, &ops
);
828 snd_timer_free(timer
);
837 static int snd_timer_free(struct snd_timer
*timer
)
842 mutex_lock(®ister_mutex
);
843 if (! list_empty(&timer
->open_list_head
)) {
844 struct list_head
*p
, *n
;
845 struct snd_timer_instance
*ti
;
846 pr_warn("ALSA: timer %p is busy?\n", timer
);
847 list_for_each_safe(p
, n
, &timer
->open_list_head
) {
849 ti
= list_entry(p
, struct snd_timer_instance
, open_list
);
853 list_del(&timer
->device_list
);
854 mutex_unlock(®ister_mutex
);
856 if (timer
->private_free
)
857 timer
->private_free(timer
);
862 static int snd_timer_dev_free(struct snd_device
*device
)
864 struct snd_timer
*timer
= device
->device_data
;
865 return snd_timer_free(timer
);
868 static int snd_timer_dev_register(struct snd_device
*dev
)
870 struct snd_timer
*timer
= dev
->device_data
;
871 struct snd_timer
*timer1
;
873 if (snd_BUG_ON(!timer
|| !timer
->hw
.start
|| !timer
->hw
.stop
))
875 if (!(timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
) &&
876 !timer
->hw
.resolution
&& timer
->hw
.c_resolution
== NULL
)
879 mutex_lock(®ister_mutex
);
880 list_for_each_entry(timer1
, &snd_timer_list
, device_list
) {
881 if (timer1
->tmr_class
> timer
->tmr_class
)
883 if (timer1
->tmr_class
< timer
->tmr_class
)
885 if (timer1
->card
&& timer
->card
) {
886 if (timer1
->card
->number
> timer
->card
->number
)
888 if (timer1
->card
->number
< timer
->card
->number
)
891 if (timer1
->tmr_device
> timer
->tmr_device
)
893 if (timer1
->tmr_device
< timer
->tmr_device
)
895 if (timer1
->tmr_subdevice
> timer
->tmr_subdevice
)
897 if (timer1
->tmr_subdevice
< timer
->tmr_subdevice
)
900 mutex_unlock(®ister_mutex
);
903 list_add_tail(&timer
->device_list
, &timer1
->device_list
);
904 mutex_unlock(®ister_mutex
);
908 static int snd_timer_dev_disconnect(struct snd_device
*device
)
910 struct snd_timer
*timer
= device
->device_data
;
911 struct snd_timer_instance
*ti
;
913 mutex_lock(®ister_mutex
);
914 list_del_init(&timer
->device_list
);
915 /* wake up pending sleepers */
916 list_for_each_entry(ti
, &timer
->open_list_head
, open_list
) {
920 mutex_unlock(®ister_mutex
);
924 void snd_timer_notify(struct snd_timer
*timer
, int event
, struct timespec
*tstamp
)
927 unsigned long resolution
= 0;
928 struct snd_timer_instance
*ti
, *ts
;
930 if (timer
->card
&& timer
->card
->shutdown
)
932 if (! (timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
))
934 if (snd_BUG_ON(event
< SNDRV_TIMER_EVENT_MSTART
||
935 event
> SNDRV_TIMER_EVENT_MRESUME
))
937 spin_lock_irqsave(&timer
->lock
, flags
);
938 if (event
== SNDRV_TIMER_EVENT_MSTART
||
939 event
== SNDRV_TIMER_EVENT_MCONTINUE
||
940 event
== SNDRV_TIMER_EVENT_MRESUME
) {
941 if (timer
->hw
.c_resolution
)
942 resolution
= timer
->hw
.c_resolution(timer
);
944 resolution
= timer
->hw
.resolution
;
946 list_for_each_entry(ti
, &timer
->active_list_head
, active_list
) {
948 ti
->ccallback(ti
, event
, tstamp
, resolution
);
949 list_for_each_entry(ts
, &ti
->slave_active_head
, active_list
)
951 ts
->ccallback(ts
, event
, tstamp
, resolution
);
953 spin_unlock_irqrestore(&timer
->lock
, flags
);
957 * exported functions for global timers
959 int snd_timer_global_new(char *id
, int device
, struct snd_timer
**rtimer
)
961 struct snd_timer_id tid
;
963 tid
.dev_class
= SNDRV_TIMER_CLASS_GLOBAL
;
964 tid
.dev_sclass
= SNDRV_TIMER_SCLASS_NONE
;
968 return snd_timer_new(NULL
, id
, &tid
, rtimer
);
971 int snd_timer_global_free(struct snd_timer
*timer
)
973 return snd_timer_free(timer
);
976 int snd_timer_global_register(struct snd_timer
*timer
)
978 struct snd_device dev
;
980 memset(&dev
, 0, sizeof(dev
));
981 dev
.device_data
= timer
;
982 return snd_timer_dev_register(&dev
);
989 struct snd_timer_system_private
{
990 struct timer_list tlist
;
991 unsigned long last_expires
;
992 unsigned long last_jiffies
;
993 unsigned long correction
;
996 static void snd_timer_s_function(unsigned long data
)
998 struct snd_timer
*timer
= (struct snd_timer
*)data
;
999 struct snd_timer_system_private
*priv
= timer
->private_data
;
1000 unsigned long jiff
= jiffies
;
1001 if (time_after(jiff
, priv
->last_expires
))
1002 priv
->correction
+= (long)jiff
- (long)priv
->last_expires
;
1003 snd_timer_interrupt(timer
, (long)jiff
- (long)priv
->last_jiffies
);
1006 static int snd_timer_s_start(struct snd_timer
* timer
)
1008 struct snd_timer_system_private
*priv
;
1009 unsigned long njiff
;
1011 priv
= (struct snd_timer_system_private
*) timer
->private_data
;
1012 njiff
= (priv
->last_jiffies
= jiffies
);
1013 if (priv
->correction
> timer
->sticks
- 1) {
1014 priv
->correction
-= timer
->sticks
- 1;
1017 njiff
+= timer
->sticks
- priv
->correction
;
1018 priv
->correction
= 0;
1020 priv
->last_expires
= njiff
;
1021 mod_timer(&priv
->tlist
, njiff
);
1025 static int snd_timer_s_stop(struct snd_timer
* timer
)
1027 struct snd_timer_system_private
*priv
;
1030 priv
= (struct snd_timer_system_private
*) timer
->private_data
;
1031 del_timer(&priv
->tlist
);
1033 if (time_before(jiff
, priv
->last_expires
))
1034 timer
->sticks
= priv
->last_expires
- jiff
;
1037 priv
->correction
= 0;
1041 static int snd_timer_s_close(struct snd_timer
*timer
)
1043 struct snd_timer_system_private
*priv
;
1045 priv
= (struct snd_timer_system_private
*)timer
->private_data
;
1046 del_timer_sync(&priv
->tlist
);
1050 static struct snd_timer_hardware snd_timer_system
=
1052 .flags
= SNDRV_TIMER_HW_FIRST
| SNDRV_TIMER_HW_TASKLET
,
1053 .resolution
= 1000000000L / HZ
,
1055 .close
= snd_timer_s_close
,
1056 .start
= snd_timer_s_start
,
1057 .stop
= snd_timer_s_stop
1060 static void snd_timer_free_system(struct snd_timer
*timer
)
1062 kfree(timer
->private_data
);
1065 static int snd_timer_register_system(void)
1067 struct snd_timer
*timer
;
1068 struct snd_timer_system_private
*priv
;
1071 err
= snd_timer_global_new("system", SNDRV_TIMER_GLOBAL_SYSTEM
, &timer
);
1074 strcpy(timer
->name
, "system timer");
1075 timer
->hw
= snd_timer_system
;
1076 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
1078 snd_timer_free(timer
);
1081 setup_timer(&priv
->tlist
, snd_timer_s_function
, (unsigned long) timer
);
1082 timer
->private_data
= priv
;
1083 timer
->private_free
= snd_timer_free_system
;
1084 return snd_timer_global_register(timer
);
1087 #ifdef CONFIG_SND_PROC_FS
1092 static void snd_timer_proc_read(struct snd_info_entry
*entry
,
1093 struct snd_info_buffer
*buffer
)
1095 struct snd_timer
*timer
;
1096 struct snd_timer_instance
*ti
;
1098 mutex_lock(®ister_mutex
);
1099 list_for_each_entry(timer
, &snd_timer_list
, device_list
) {
1100 if (timer
->card
&& timer
->card
->shutdown
)
1102 switch (timer
->tmr_class
) {
1103 case SNDRV_TIMER_CLASS_GLOBAL
:
1104 snd_iprintf(buffer
, "G%i: ", timer
->tmr_device
);
1106 case SNDRV_TIMER_CLASS_CARD
:
1107 snd_iprintf(buffer
, "C%i-%i: ",
1108 timer
->card
->number
, timer
->tmr_device
);
1110 case SNDRV_TIMER_CLASS_PCM
:
1111 snd_iprintf(buffer
, "P%i-%i-%i: ", timer
->card
->number
,
1112 timer
->tmr_device
, timer
->tmr_subdevice
);
1115 snd_iprintf(buffer
, "?%i-%i-%i-%i: ", timer
->tmr_class
,
1116 timer
->card
? timer
->card
->number
: -1,
1117 timer
->tmr_device
, timer
->tmr_subdevice
);
1119 snd_iprintf(buffer
, "%s :", timer
->name
);
1120 if (timer
->hw
.resolution
)
1121 snd_iprintf(buffer
, " %lu.%03luus (%lu ticks)",
1122 timer
->hw
.resolution
/ 1000,
1123 timer
->hw
.resolution
% 1000,
1125 if (timer
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
1126 snd_iprintf(buffer
, " SLAVE");
1127 snd_iprintf(buffer
, "\n");
1128 list_for_each_entry(ti
, &timer
->open_list_head
, open_list
)
1129 snd_iprintf(buffer
, " Client %s : %s\n",
1130 ti
->owner
? ti
->owner
: "unknown",
1131 ti
->flags
& (SNDRV_TIMER_IFLG_START
|
1132 SNDRV_TIMER_IFLG_RUNNING
)
1133 ? "running" : "stopped");
1135 mutex_unlock(®ister_mutex
);
1138 static struct snd_info_entry
*snd_timer_proc_entry
;
1140 static void __init
snd_timer_proc_init(void)
1142 struct snd_info_entry
*entry
;
1144 entry
= snd_info_create_module_entry(THIS_MODULE
, "timers", NULL
);
1145 if (entry
!= NULL
) {
1146 entry
->c
.text
.read
= snd_timer_proc_read
;
1147 if (snd_info_register(entry
) < 0) {
1148 snd_info_free_entry(entry
);
1152 snd_timer_proc_entry
= entry
;
1155 static void __exit
snd_timer_proc_done(void)
1157 snd_info_free_entry(snd_timer_proc_entry
);
1159 #else /* !CONFIG_SND_PROC_FS */
1160 #define snd_timer_proc_init()
1161 #define snd_timer_proc_done()
1165 * USER SPACE interface
1168 static void snd_timer_user_interrupt(struct snd_timer_instance
*timeri
,
1169 unsigned long resolution
,
1170 unsigned long ticks
)
1172 struct snd_timer_user
*tu
= timeri
->callback_data
;
1173 struct snd_timer_read
*r
;
1176 spin_lock(&tu
->qlock
);
1177 if (tu
->qused
> 0) {
1178 prev
= tu
->qtail
== 0 ? tu
->queue_size
- 1 : tu
->qtail
- 1;
1179 r
= &tu
->queue
[prev
];
1180 if (r
->resolution
== resolution
) {
1185 if (tu
->qused
>= tu
->queue_size
) {
1188 r
= &tu
->queue
[tu
->qtail
++];
1189 tu
->qtail
%= tu
->queue_size
;
1190 r
->resolution
= resolution
;
1195 spin_unlock(&tu
->qlock
);
1196 kill_fasync(&tu
->fasync
, SIGIO
, POLL_IN
);
1197 wake_up(&tu
->qchange_sleep
);
1200 static void snd_timer_user_append_to_tqueue(struct snd_timer_user
*tu
,
1201 struct snd_timer_tread
*tread
)
1203 if (tu
->qused
>= tu
->queue_size
) {
1206 memcpy(&tu
->tqueue
[tu
->qtail
++], tread
, sizeof(*tread
));
1207 tu
->qtail
%= tu
->queue_size
;
1212 static void snd_timer_user_ccallback(struct snd_timer_instance
*timeri
,
1214 struct timespec
*tstamp
,
1215 unsigned long resolution
)
1217 struct snd_timer_user
*tu
= timeri
->callback_data
;
1218 struct snd_timer_tread r1
;
1219 unsigned long flags
;
1221 if (event
>= SNDRV_TIMER_EVENT_START
&&
1222 event
<= SNDRV_TIMER_EVENT_PAUSE
)
1223 tu
->tstamp
= *tstamp
;
1224 if ((tu
->filter
& (1 << event
)) == 0 || !tu
->tread
)
1226 memset(&r1
, 0, sizeof(r1
));
1228 r1
.tstamp
= *tstamp
;
1229 r1
.val
= resolution
;
1230 spin_lock_irqsave(&tu
->qlock
, flags
);
1231 snd_timer_user_append_to_tqueue(tu
, &r1
);
1232 spin_unlock_irqrestore(&tu
->qlock
, flags
);
1233 kill_fasync(&tu
->fasync
, SIGIO
, POLL_IN
);
1234 wake_up(&tu
->qchange_sleep
);
1237 static void snd_timer_user_disconnect(struct snd_timer_instance
*timeri
)
1239 struct snd_timer_user
*tu
= timeri
->callback_data
;
1241 tu
->disconnected
= true;
1242 wake_up(&tu
->qchange_sleep
);
1245 static void snd_timer_user_tinterrupt(struct snd_timer_instance
*timeri
,
1246 unsigned long resolution
,
1247 unsigned long ticks
)
1249 struct snd_timer_user
*tu
= timeri
->callback_data
;
1250 struct snd_timer_tread
*r
, r1
;
1251 struct timespec tstamp
;
1252 int prev
, append
= 0;
1254 memset(&tstamp
, 0, sizeof(tstamp
));
1255 spin_lock(&tu
->qlock
);
1256 if ((tu
->filter
& ((1 << SNDRV_TIMER_EVENT_RESOLUTION
) |
1257 (1 << SNDRV_TIMER_EVENT_TICK
))) == 0) {
1258 spin_unlock(&tu
->qlock
);
1261 if (tu
->last_resolution
!= resolution
|| ticks
> 0) {
1262 if (timer_tstamp_monotonic
)
1263 ktime_get_ts(&tstamp
);
1265 getnstimeofday(&tstamp
);
1267 if ((tu
->filter
& (1 << SNDRV_TIMER_EVENT_RESOLUTION
)) &&
1268 tu
->last_resolution
!= resolution
) {
1269 memset(&r1
, 0, sizeof(r1
));
1270 r1
.event
= SNDRV_TIMER_EVENT_RESOLUTION
;
1272 r1
.val
= resolution
;
1273 snd_timer_user_append_to_tqueue(tu
, &r1
);
1274 tu
->last_resolution
= resolution
;
1277 if ((tu
->filter
& (1 << SNDRV_TIMER_EVENT_TICK
)) == 0)
1281 if (tu
->qused
> 0) {
1282 prev
= tu
->qtail
== 0 ? tu
->queue_size
- 1 : tu
->qtail
- 1;
1283 r
= &tu
->tqueue
[prev
];
1284 if (r
->event
== SNDRV_TIMER_EVENT_TICK
) {
1291 r1
.event
= SNDRV_TIMER_EVENT_TICK
;
1294 snd_timer_user_append_to_tqueue(tu
, &r1
);
1297 spin_unlock(&tu
->qlock
);
1300 kill_fasync(&tu
->fasync
, SIGIO
, POLL_IN
);
1301 wake_up(&tu
->qchange_sleep
);
1304 static int snd_timer_user_open(struct inode
*inode
, struct file
*file
)
1306 struct snd_timer_user
*tu
;
1309 err
= nonseekable_open(inode
, file
);
1313 tu
= kzalloc(sizeof(*tu
), GFP_KERNEL
);
1316 spin_lock_init(&tu
->qlock
);
1317 init_waitqueue_head(&tu
->qchange_sleep
);
1318 mutex_init(&tu
->ioctl_lock
);
1320 tu
->queue_size
= 128;
1321 tu
->queue
= kmalloc(tu
->queue_size
* sizeof(struct snd_timer_read
),
1323 if (tu
->queue
== NULL
) {
1327 file
->private_data
= tu
;
1331 static int snd_timer_user_release(struct inode
*inode
, struct file
*file
)
1333 struct snd_timer_user
*tu
;
1335 if (file
->private_data
) {
1336 tu
= file
->private_data
;
1337 file
->private_data
= NULL
;
1338 mutex_lock(&tu
->ioctl_lock
);
1340 snd_timer_close(tu
->timeri
);
1341 mutex_unlock(&tu
->ioctl_lock
);
1349 static void snd_timer_user_zero_id(struct snd_timer_id
*id
)
1351 id
->dev_class
= SNDRV_TIMER_CLASS_NONE
;
1352 id
->dev_sclass
= SNDRV_TIMER_SCLASS_NONE
;
1358 static void snd_timer_user_copy_id(struct snd_timer_id
*id
, struct snd_timer
*timer
)
1360 id
->dev_class
= timer
->tmr_class
;
1361 id
->dev_sclass
= SNDRV_TIMER_SCLASS_NONE
;
1362 id
->card
= timer
->card
? timer
->card
->number
: -1;
1363 id
->device
= timer
->tmr_device
;
1364 id
->subdevice
= timer
->tmr_subdevice
;
1367 static int snd_timer_user_next_device(struct snd_timer_id __user
*_tid
)
1369 struct snd_timer_id id
;
1370 struct snd_timer
*timer
;
1371 struct list_head
*p
;
1373 if (copy_from_user(&id
, _tid
, sizeof(id
)))
1375 mutex_lock(®ister_mutex
);
1376 if (id
.dev_class
< 0) { /* first item */
1377 if (list_empty(&snd_timer_list
))
1378 snd_timer_user_zero_id(&id
);
1380 timer
= list_entry(snd_timer_list
.next
,
1381 struct snd_timer
, device_list
);
1382 snd_timer_user_copy_id(&id
, timer
);
1385 switch (id
.dev_class
) {
1386 case SNDRV_TIMER_CLASS_GLOBAL
:
1387 id
.device
= id
.device
< 0 ? 0 : id
.device
+ 1;
1388 list_for_each(p
, &snd_timer_list
) {
1389 timer
= list_entry(p
, struct snd_timer
, device_list
);
1390 if (timer
->tmr_class
> SNDRV_TIMER_CLASS_GLOBAL
) {
1391 snd_timer_user_copy_id(&id
, timer
);
1394 if (timer
->tmr_device
>= id
.device
) {
1395 snd_timer_user_copy_id(&id
, timer
);
1399 if (p
== &snd_timer_list
)
1400 snd_timer_user_zero_id(&id
);
1402 case SNDRV_TIMER_CLASS_CARD
:
1403 case SNDRV_TIMER_CLASS_PCM
:
1410 if (id
.device
< 0) {
1413 if (id
.subdevice
< 0) {
1421 list_for_each(p
, &snd_timer_list
) {
1422 timer
= list_entry(p
, struct snd_timer
, device_list
);
1423 if (timer
->tmr_class
> id
.dev_class
) {
1424 snd_timer_user_copy_id(&id
, timer
);
1427 if (timer
->tmr_class
< id
.dev_class
)
1429 if (timer
->card
->number
> id
.card
) {
1430 snd_timer_user_copy_id(&id
, timer
);
1433 if (timer
->card
->number
< id
.card
)
1435 if (timer
->tmr_device
> id
.device
) {
1436 snd_timer_user_copy_id(&id
, timer
);
1439 if (timer
->tmr_device
< id
.device
)
1441 if (timer
->tmr_subdevice
> id
.subdevice
) {
1442 snd_timer_user_copy_id(&id
, timer
);
1445 if (timer
->tmr_subdevice
< id
.subdevice
)
1447 snd_timer_user_copy_id(&id
, timer
);
1450 if (p
== &snd_timer_list
)
1451 snd_timer_user_zero_id(&id
);
1454 snd_timer_user_zero_id(&id
);
1457 mutex_unlock(®ister_mutex
);
1458 if (copy_to_user(_tid
, &id
, sizeof(*_tid
)))
1463 static int snd_timer_user_ginfo(struct file
*file
,
1464 struct snd_timer_ginfo __user
*_ginfo
)
1466 struct snd_timer_ginfo
*ginfo
;
1467 struct snd_timer_id tid
;
1468 struct snd_timer
*t
;
1469 struct list_head
*p
;
1472 ginfo
= memdup_user(_ginfo
, sizeof(*ginfo
));
1474 return PTR_ERR(ginfo
);
1477 memset(ginfo
, 0, sizeof(*ginfo
));
1479 mutex_lock(®ister_mutex
);
1480 t
= snd_timer_find(&tid
);
1482 ginfo
->card
= t
->card
? t
->card
->number
: -1;
1483 if (t
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
1484 ginfo
->flags
|= SNDRV_TIMER_FLG_SLAVE
;
1485 strlcpy(ginfo
->id
, t
->id
, sizeof(ginfo
->id
));
1486 strlcpy(ginfo
->name
, t
->name
, sizeof(ginfo
->name
));
1487 ginfo
->resolution
= t
->hw
.resolution
;
1488 if (t
->hw
.resolution_min
> 0) {
1489 ginfo
->resolution_min
= t
->hw
.resolution_min
;
1490 ginfo
->resolution_max
= t
->hw
.resolution_max
;
1492 list_for_each(p
, &t
->open_list_head
) {
1498 mutex_unlock(®ister_mutex
);
1499 if (err
>= 0 && copy_to_user(_ginfo
, ginfo
, sizeof(*ginfo
)))
1505 static int timer_set_gparams(struct snd_timer_gparams
*gparams
)
1507 struct snd_timer
*t
;
1510 mutex_lock(®ister_mutex
);
1511 t
= snd_timer_find(&gparams
->tid
);
1516 if (!list_empty(&t
->open_list_head
)) {
1520 if (!t
->hw
.set_period
) {
1524 err
= t
->hw
.set_period(t
, gparams
->period_num
, gparams
->period_den
);
1526 mutex_unlock(®ister_mutex
);
1530 static int snd_timer_user_gparams(struct file
*file
,
1531 struct snd_timer_gparams __user
*_gparams
)
1533 struct snd_timer_gparams gparams
;
1535 if (copy_from_user(&gparams
, _gparams
, sizeof(gparams
)))
1537 return timer_set_gparams(&gparams
);
1540 static int snd_timer_user_gstatus(struct file
*file
,
1541 struct snd_timer_gstatus __user
*_gstatus
)
1543 struct snd_timer_gstatus gstatus
;
1544 struct snd_timer_id tid
;
1545 struct snd_timer
*t
;
1548 if (copy_from_user(&gstatus
, _gstatus
, sizeof(gstatus
)))
1551 memset(&gstatus
, 0, sizeof(gstatus
));
1553 mutex_lock(®ister_mutex
);
1554 t
= snd_timer_find(&tid
);
1556 if (t
->hw
.c_resolution
)
1557 gstatus
.resolution
= t
->hw
.c_resolution(t
);
1559 gstatus
.resolution
= t
->hw
.resolution
;
1560 if (t
->hw
.precise_resolution
) {
1561 t
->hw
.precise_resolution(t
, &gstatus
.resolution_num
,
1562 &gstatus
.resolution_den
);
1564 gstatus
.resolution_num
= gstatus
.resolution
;
1565 gstatus
.resolution_den
= 1000000000uL;
1570 mutex_unlock(®ister_mutex
);
1571 if (err
>= 0 && copy_to_user(_gstatus
, &gstatus
, sizeof(gstatus
)))
1576 static int snd_timer_user_tselect(struct file
*file
,
1577 struct snd_timer_select __user
*_tselect
)
1579 struct snd_timer_user
*tu
;
1580 struct snd_timer_select tselect
;
1584 tu
= file
->private_data
;
1586 snd_timer_close(tu
->timeri
);
1589 if (copy_from_user(&tselect
, _tselect
, sizeof(tselect
))) {
1593 sprintf(str
, "application %i", current
->pid
);
1594 if (tselect
.id
.dev_class
!= SNDRV_TIMER_CLASS_SLAVE
)
1595 tselect
.id
.dev_sclass
= SNDRV_TIMER_SCLASS_APPLICATION
;
1596 err
= snd_timer_open(&tu
->timeri
, str
, &tselect
.id
, current
->pid
);
1605 tu
->tqueue
= kmalloc(tu
->queue_size
* sizeof(struct snd_timer_tread
),
1607 if (tu
->tqueue
== NULL
)
1610 tu
->queue
= kmalloc(tu
->queue_size
* sizeof(struct snd_timer_read
),
1612 if (tu
->queue
== NULL
)
1617 snd_timer_close(tu
->timeri
);
1620 tu
->timeri
->flags
|= SNDRV_TIMER_IFLG_FAST
;
1621 tu
->timeri
->callback
= tu
->tread
1622 ? snd_timer_user_tinterrupt
: snd_timer_user_interrupt
;
1623 tu
->timeri
->ccallback
= snd_timer_user_ccallback
;
1624 tu
->timeri
->callback_data
= (void *)tu
;
1625 tu
->timeri
->disconnect
= snd_timer_user_disconnect
;
1632 static int snd_timer_user_info(struct file
*file
,
1633 struct snd_timer_info __user
*_info
)
1635 struct snd_timer_user
*tu
;
1636 struct snd_timer_info
*info
;
1637 struct snd_timer
*t
;
1640 tu
= file
->private_data
;
1643 t
= tu
->timeri
->timer
;
1647 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
1650 info
->card
= t
->card
? t
->card
->number
: -1;
1651 if (t
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)
1652 info
->flags
|= SNDRV_TIMER_FLG_SLAVE
;
1653 strlcpy(info
->id
, t
->id
, sizeof(info
->id
));
1654 strlcpy(info
->name
, t
->name
, sizeof(info
->name
));
1655 info
->resolution
= t
->hw
.resolution
;
1656 if (copy_to_user(_info
, info
, sizeof(*_info
)))
1662 static int snd_timer_user_params(struct file
*file
,
1663 struct snd_timer_params __user
*_params
)
1665 struct snd_timer_user
*tu
;
1666 struct snd_timer_params params
;
1667 struct snd_timer
*t
;
1668 struct snd_timer_read
*tr
;
1669 struct snd_timer_tread
*ttr
;
1672 tu
= file
->private_data
;
1675 t
= tu
->timeri
->timer
;
1678 if (copy_from_user(¶ms
, _params
, sizeof(params
)))
1680 if (!(t
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
) && params
.ticks
< 1) {
1684 if (params
.queue_size
> 0 &&
1685 (params
.queue_size
< 32 || params
.queue_size
> 1024)) {
1689 if (params
.filter
& ~((1<<SNDRV_TIMER_EVENT_RESOLUTION
)|
1690 (1<<SNDRV_TIMER_EVENT_TICK
)|
1691 (1<<SNDRV_TIMER_EVENT_START
)|
1692 (1<<SNDRV_TIMER_EVENT_STOP
)|
1693 (1<<SNDRV_TIMER_EVENT_CONTINUE
)|
1694 (1<<SNDRV_TIMER_EVENT_PAUSE
)|
1695 (1<<SNDRV_TIMER_EVENT_SUSPEND
)|
1696 (1<<SNDRV_TIMER_EVENT_RESUME
)|
1697 (1<<SNDRV_TIMER_EVENT_MSTART
)|
1698 (1<<SNDRV_TIMER_EVENT_MSTOP
)|
1699 (1<<SNDRV_TIMER_EVENT_MCONTINUE
)|
1700 (1<<SNDRV_TIMER_EVENT_MPAUSE
)|
1701 (1<<SNDRV_TIMER_EVENT_MSUSPEND
)|
1702 (1<<SNDRV_TIMER_EVENT_MRESUME
))) {
1706 snd_timer_stop(tu
->timeri
);
1707 spin_lock_irq(&t
->lock
);
1708 tu
->timeri
->flags
&= ~(SNDRV_TIMER_IFLG_AUTO
|
1709 SNDRV_TIMER_IFLG_EXCLUSIVE
|
1710 SNDRV_TIMER_IFLG_EARLY_EVENT
);
1711 if (params
.flags
& SNDRV_TIMER_PSFLG_AUTO
)
1712 tu
->timeri
->flags
|= SNDRV_TIMER_IFLG_AUTO
;
1713 if (params
.flags
& SNDRV_TIMER_PSFLG_EXCLUSIVE
)
1714 tu
->timeri
->flags
|= SNDRV_TIMER_IFLG_EXCLUSIVE
;
1715 if (params
.flags
& SNDRV_TIMER_PSFLG_EARLY_EVENT
)
1716 tu
->timeri
->flags
|= SNDRV_TIMER_IFLG_EARLY_EVENT
;
1717 spin_unlock_irq(&t
->lock
);
1718 if (params
.queue_size
> 0 &&
1719 (unsigned int)tu
->queue_size
!= params
.queue_size
) {
1721 ttr
= kmalloc(params
.queue_size
* sizeof(*ttr
),
1725 tu
->queue_size
= params
.queue_size
;
1729 tr
= kmalloc(params
.queue_size
* sizeof(*tr
),
1733 tu
->queue_size
= params
.queue_size
;
1738 tu
->qhead
= tu
->qtail
= tu
->qused
= 0;
1739 if (tu
->timeri
->flags
& SNDRV_TIMER_IFLG_EARLY_EVENT
) {
1741 struct snd_timer_tread tread
;
1742 memset(&tread
, 0, sizeof(tread
));
1743 tread
.event
= SNDRV_TIMER_EVENT_EARLY
;
1744 tread
.tstamp
.tv_sec
= 0;
1745 tread
.tstamp
.tv_nsec
= 0;
1747 snd_timer_user_append_to_tqueue(tu
, &tread
);
1749 struct snd_timer_read
*r
= &tu
->queue
[0];
1756 tu
->filter
= params
.filter
;
1757 tu
->ticks
= params
.ticks
;
1760 if (copy_to_user(_params
, ¶ms
, sizeof(params
)))
1765 static int snd_timer_user_status(struct file
*file
,
1766 struct snd_timer_status __user
*_status
)
1768 struct snd_timer_user
*tu
;
1769 struct snd_timer_status status
;
1771 tu
= file
->private_data
;
1774 memset(&status
, 0, sizeof(status
));
1775 status
.tstamp
= tu
->tstamp
;
1776 status
.resolution
= snd_timer_resolution(tu
->timeri
);
1777 status
.lost
= tu
->timeri
->lost
;
1778 status
.overrun
= tu
->overrun
;
1779 spin_lock_irq(&tu
->qlock
);
1780 status
.queue
= tu
->qused
;
1781 spin_unlock_irq(&tu
->qlock
);
1782 if (copy_to_user(_status
, &status
, sizeof(status
)))
1787 static int snd_timer_user_start(struct file
*file
)
1790 struct snd_timer_user
*tu
;
1792 tu
= file
->private_data
;
1795 snd_timer_stop(tu
->timeri
);
1796 tu
->timeri
->lost
= 0;
1797 tu
->last_resolution
= 0;
1798 return (err
= snd_timer_start(tu
->timeri
, tu
->ticks
)) < 0 ? err
: 0;
1801 static int snd_timer_user_stop(struct file
*file
)
1804 struct snd_timer_user
*tu
;
1806 tu
= file
->private_data
;
1809 return (err
= snd_timer_stop(tu
->timeri
)) < 0 ? err
: 0;
1812 static int snd_timer_user_continue(struct file
*file
)
1815 struct snd_timer_user
*tu
;
1817 tu
= file
->private_data
;
1820 tu
->timeri
->lost
= 0;
1821 return (err
= snd_timer_continue(tu
->timeri
)) < 0 ? err
: 0;
1824 static int snd_timer_user_pause(struct file
*file
)
1827 struct snd_timer_user
*tu
;
1829 tu
= file
->private_data
;
1832 return (err
= snd_timer_pause(tu
->timeri
)) < 0 ? err
: 0;
1836 SNDRV_TIMER_IOCTL_START_OLD
= _IO('T', 0x20),
1837 SNDRV_TIMER_IOCTL_STOP_OLD
= _IO('T', 0x21),
1838 SNDRV_TIMER_IOCTL_CONTINUE_OLD
= _IO('T', 0x22),
1839 SNDRV_TIMER_IOCTL_PAUSE_OLD
= _IO('T', 0x23),
1842 static long __snd_timer_user_ioctl(struct file
*file
, unsigned int cmd
,
1845 struct snd_timer_user
*tu
;
1846 void __user
*argp
= (void __user
*)arg
;
1847 int __user
*p
= argp
;
1849 tu
= file
->private_data
;
1851 case SNDRV_TIMER_IOCTL_PVERSION
:
1852 return put_user(SNDRV_TIMER_VERSION
, p
) ? -EFAULT
: 0;
1853 case SNDRV_TIMER_IOCTL_NEXT_DEVICE
:
1854 return snd_timer_user_next_device(argp
);
1855 case SNDRV_TIMER_IOCTL_TREAD
:
1859 if (tu
->timeri
) /* too late */
1861 if (get_user(xarg
, p
))
1863 tu
->tread
= xarg
? 1 : 0;
1866 case SNDRV_TIMER_IOCTL_GINFO
:
1867 return snd_timer_user_ginfo(file
, argp
);
1868 case SNDRV_TIMER_IOCTL_GPARAMS
:
1869 return snd_timer_user_gparams(file
, argp
);
1870 case SNDRV_TIMER_IOCTL_GSTATUS
:
1871 return snd_timer_user_gstatus(file
, argp
);
1872 case SNDRV_TIMER_IOCTL_SELECT
:
1873 return snd_timer_user_tselect(file
, argp
);
1874 case SNDRV_TIMER_IOCTL_INFO
:
1875 return snd_timer_user_info(file
, argp
);
1876 case SNDRV_TIMER_IOCTL_PARAMS
:
1877 return snd_timer_user_params(file
, argp
);
1878 case SNDRV_TIMER_IOCTL_STATUS
:
1879 return snd_timer_user_status(file
, argp
);
1880 case SNDRV_TIMER_IOCTL_START
:
1881 case SNDRV_TIMER_IOCTL_START_OLD
:
1882 return snd_timer_user_start(file
);
1883 case SNDRV_TIMER_IOCTL_STOP
:
1884 case SNDRV_TIMER_IOCTL_STOP_OLD
:
1885 return snd_timer_user_stop(file
);
1886 case SNDRV_TIMER_IOCTL_CONTINUE
:
1887 case SNDRV_TIMER_IOCTL_CONTINUE_OLD
:
1888 return snd_timer_user_continue(file
);
1889 case SNDRV_TIMER_IOCTL_PAUSE
:
1890 case SNDRV_TIMER_IOCTL_PAUSE_OLD
:
1891 return snd_timer_user_pause(file
);
1896 static long snd_timer_user_ioctl(struct file
*file
, unsigned int cmd
,
1899 struct snd_timer_user
*tu
= file
->private_data
;
1902 mutex_lock(&tu
->ioctl_lock
);
1903 ret
= __snd_timer_user_ioctl(file
, cmd
, arg
);
1904 mutex_unlock(&tu
->ioctl_lock
);
1908 static int snd_timer_user_fasync(int fd
, struct file
* file
, int on
)
1910 struct snd_timer_user
*tu
;
1912 tu
= file
->private_data
;
1913 return fasync_helper(fd
, file
, on
, &tu
->fasync
);
1916 static ssize_t
snd_timer_user_read(struct file
*file
, char __user
*buffer
,
1917 size_t count
, loff_t
*offset
)
1919 struct snd_timer_user
*tu
;
1920 long result
= 0, unit
;
1924 tu
= file
->private_data
;
1925 unit
= tu
->tread
? sizeof(struct snd_timer_tread
) : sizeof(struct snd_timer_read
);
1926 spin_lock_irq(&tu
->qlock
);
1927 while ((long)count
- result
>= unit
) {
1928 while (!tu
->qused
) {
1931 if ((file
->f_flags
& O_NONBLOCK
) != 0 || result
> 0) {
1936 set_current_state(TASK_INTERRUPTIBLE
);
1937 init_waitqueue_entry(&wait
, current
);
1938 add_wait_queue(&tu
->qchange_sleep
, &wait
);
1940 spin_unlock_irq(&tu
->qlock
);
1942 spin_lock_irq(&tu
->qlock
);
1944 remove_wait_queue(&tu
->qchange_sleep
, &wait
);
1946 if (tu
->disconnected
) {
1950 if (signal_pending(current
)) {
1956 qhead
= tu
->qhead
++;
1957 tu
->qhead
%= tu
->queue_size
;
1959 spin_unlock_irq(&tu
->qlock
);
1962 if (copy_to_user(buffer
, &tu
->tqueue
[qhead
],
1963 sizeof(struct snd_timer_tread
)))
1966 if (copy_to_user(buffer
, &tu
->queue
[qhead
],
1967 sizeof(struct snd_timer_read
)))
1971 spin_lock_irq(&tu
->qlock
);
1978 spin_unlock_irq(&tu
->qlock
);
1979 return result
> 0 ? result
: err
;
1982 static unsigned int snd_timer_user_poll(struct file
*file
, poll_table
* wait
)
1985 struct snd_timer_user
*tu
;
1987 tu
= file
->private_data
;
1989 poll_wait(file
, &tu
->qchange_sleep
, wait
);
1993 mask
|= POLLIN
| POLLRDNORM
;
1994 if (tu
->disconnected
)
2000 #ifdef CONFIG_COMPAT
2001 #include "timer_compat.c"
2003 #define snd_timer_user_ioctl_compat NULL
2006 static const struct file_operations snd_timer_f_ops
=
2008 .owner
= THIS_MODULE
,
2009 .read
= snd_timer_user_read
,
2010 .open
= snd_timer_user_open
,
2011 .release
= snd_timer_user_release
,
2012 .llseek
= no_llseek
,
2013 .poll
= snd_timer_user_poll
,
2014 .unlocked_ioctl
= snd_timer_user_ioctl
,
2015 .compat_ioctl
= snd_timer_user_ioctl_compat
,
2016 .fasync
= snd_timer_user_fasync
,
2019 /* unregister the system timer */
2020 static void snd_timer_free_all(void)
2022 struct snd_timer
*timer
, *n
;
2024 list_for_each_entry_safe(timer
, n
, &snd_timer_list
, device_list
)
2025 snd_timer_free(timer
);
2028 static struct device timer_dev
;
2034 static int __init
alsa_timer_init(void)
2038 snd_device_initialize(&timer_dev
, NULL
);
2039 dev_set_name(&timer_dev
, "timer");
2041 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
2042 snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS
, SNDRV_CARDS
- 1,
2046 err
= snd_timer_register_system();
2048 pr_err("ALSA: unable to register system timer (%i)\n", err
);
2049 put_device(&timer_dev
);
2053 err
= snd_register_device(SNDRV_DEVICE_TYPE_TIMER
, NULL
, 0,
2054 &snd_timer_f_ops
, NULL
, &timer_dev
);
2056 pr_err("ALSA: unable to register timer device (%i)\n", err
);
2057 snd_timer_free_all();
2058 put_device(&timer_dev
);
2062 snd_timer_proc_init();
2066 static void __exit
alsa_timer_exit(void)
2068 snd_unregister_device(&timer_dev
);
2069 snd_timer_free_all();
2070 put_device(&timer_dev
);
2071 snd_timer_proc_done();
2072 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
2073 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS
, SNDRV_CARDS
- 1);
2077 module_init(alsa_timer_init
)
2078 module_exit(alsa_timer_exit
)
2080 EXPORT_SYMBOL(snd_timer_open
);
2081 EXPORT_SYMBOL(snd_timer_close
);
2082 EXPORT_SYMBOL(snd_timer_resolution
);
2083 EXPORT_SYMBOL(snd_timer_start
);
2084 EXPORT_SYMBOL(snd_timer_stop
);
2085 EXPORT_SYMBOL(snd_timer_continue
);
2086 EXPORT_SYMBOL(snd_timer_pause
);
2087 EXPORT_SYMBOL(snd_timer_new
);
2088 EXPORT_SYMBOL(snd_timer_notify
);
2089 EXPORT_SYMBOL(snd_timer_global_new
);
2090 EXPORT_SYMBOL(snd_timer_global_free
);
2091 EXPORT_SYMBOL(snd_timer_global_register
);
2092 EXPORT_SYMBOL(snd_timer_interrupt
);