Lines Matching refs:timer
17 #include <sound/timer.h>
37 MODULE_DESCRIPTION("ALSA timer interface");
45 MODULE_ALIAS("devname:snd/timer");
128 static int snd_timer_free(struct snd_timer *timer);
133 static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left);
136 * create a timer instance with the given owner string.
172 * find a timer instance from the given timer id
176 struct snd_timer *timer;
178 list_for_each_entry(timer, &snd_timer_list, device_list) {
179 if (timer->tmr_class != tid->dev_class)
181 if ((timer->tmr_class == SNDRV_TIMER_CLASS_CARD ||
182 timer->tmr_class == SNDRV_TIMER_CLASS_PCM) &&
183 (timer->card == NULL ||
184 timer->card->number != tid->card))
186 if (timer->tmr_device != tid->device)
188 if (timer->tmr_subdevice != tid->subdevice)
190 return timer;
202 request_module("snd-timer-%i", tid->device);
223 if (master->timer->num_instances >= master->timer->max_instances)
226 master->timer->num_instances++;
228 spin_lock(&master->timer->lock);
230 slave->timer = master->timer;
233 spin_unlock(&master->timer->lock);
246 struct snd_timer *timer;
251 list_for_each_entry(timer, &snd_timer_list, device_list) {
252 list_for_each_entry(master, &timer->open_list_head, open_list) {
286 * open a timer instance
293 struct snd_timer *timer;
302 pr_debug("ALSA: timer: invalid slave class %i\n",
321 timer = snd_timer_find(tid);
323 if (!timer) {
327 timer = snd_timer_find(tid);
330 if (!timer) {
334 if (!list_empty(&timer->open_list_head)) {
336 list_entry(timer->open_list_head.next,
343 if (timer->num_instances >= timer->max_instances) {
347 if (!try_module_get(timer->module)) {
352 if (timer->card) {
353 get_device(&timer->card->card_dev);
354 card_dev_to_put = &timer->card->card_dev;
357 if (list_empty(&timer->open_list_head) && timer->hw.open) {
358 err = timer->hw.open(timer);
360 module_put(timer->module);
365 timeri->timer = timer;
369 list_add_tail(&timeri->open_list, &timer->open_list_head);
370 timer->num_instances++;
386 * close a timer instance
392 struct snd_timer *timer = timeri->timer;
395 if (timer) {
396 spin_lock_irq(&timer->lock);
398 spin_unlock_irq(&timer->lock);
407 /* force to stop the timer */
410 if (timer) {
411 timer->num_instances--;
413 spin_lock_irq(&timer->lock);
415 spin_unlock_irq(&timer->lock);
417 spin_lock_irq(&timer->lock);
419 spin_unlock_irq(&timer->lock);
423 spin_lock(&timer->lock);
424 timeri->timer = NULL;
428 timer->num_instances--;
430 slave->timer = NULL;
434 spin_unlock(&timer->lock);
437 /* slave doesn't need to release timer resources below */
439 timer = NULL;
442 if (timer) {
443 if (list_empty(&timer->open_list_head) && timer->hw.close)
444 timer->hw.close(timer);
446 if (timer->card)
447 *card_devp_to_put = &timer->card->card_dev;
448 module_put(timer->module);
453 * close a timer instance
471 static unsigned long snd_timer_hw_resolution(struct snd_timer *timer)
473 if (timer->hw.c_resolution)
474 return timer->hw.c_resolution(timer);
476 return timer->hw.resolution;
481 struct snd_timer * timer;
487 timer = timeri->timer;
488 if (timer) {
489 spin_lock_irqsave(&timer->lock, flags);
490 ret = snd_timer_hw_resolution(timer);
491 spin_unlock_irqrestore(&timer->lock, flags);
499 struct snd_timer *timer = ti->timer;
511 if (timer &&
514 resolution = snd_timer_hw_resolution(timer);
519 if (timer == NULL)
521 if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
529 /* start/continue a master timer */
533 struct snd_timer *timer;
537 timer = timeri->timer;
538 if (!timer)
541 spin_lock_irqsave(&timer->lock, flags);
546 if (timer->card && timer->card->shutdown) {
562 list_move_tail(&timeri->active_list, &timer->active_list_head);
563 if (timer->running) {
564 if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
566 timer->flags |= SNDRV_TIMER_FLG_RESCHED;
571 timer->sticks = ticks;
572 timer->hw.start(timer);
574 timer->running++;
581 spin_unlock_irqrestore(&timer->lock, flags);
585 /* start/continue a slave timer */
602 if (timeri->master && timeri->timer) {
603 spin_lock(&timeri->timer->lock);
608 spin_unlock(&timeri->timer->lock);
616 /* stop/pause a master timer */
619 struct snd_timer *timer;
623 timer = timeri->timer;
624 if (!timer)
626 spin_lock_irqsave(&timer->lock, flags);
634 if (timer->card && timer->card->shutdown)
641 !(--timer->running)) {
642 timer->hw.stop(timer);
643 if (timer->flags & SNDRV_TIMER_FLG_RESCHED) {
644 timer->flags &= ~SNDRV_TIMER_FLG_RESCHED;
645 snd_timer_reschedule(timer, 0);
646 if (timer->flags & SNDRV_TIMER_FLG_CHANGE) {
647 timer->flags &= ~SNDRV_TIMER_FLG_CHANGE;
648 timer->hw.start(timer);
660 spin_unlock_irqrestore(&timer->lock, flags);
664 /* stop/pause a slave timer */
673 if (timeri->timer) {
674 spin_lock(&timeri->timer->lock);
680 spin_unlock(&timeri->timer->lock);
687 * start the timer instance
701 * stop the timer instance.
703 * do not call this from the timer callback!
719 /* timer can continue only after pause */
743 * reschedule the timer
746 * when the scheduling ticks is changed set CHANGE flag to reprogram the timer.
748 static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left)
753 list_for_each_entry(ti, &timer->active_list_head, active_list) {
757 timer->running++;
765 timer->flags &= ~SNDRV_TIMER_FLG_RESCHED;
768 if (ticks > timer->hw.ticks)
769 ticks = timer->hw.ticks;
771 timer->flags |= SNDRV_TIMER_FLG_CHANGE;
772 timer->sticks = ticks;
775 /* call callbacks in timer ack list */
776 static void snd_timer_process_callbacks(struct snd_timer *timer,
794 spin_unlock(&timer->lock);
797 spin_lock(&timer->lock);
804 static void snd_timer_clear_callbacks(struct snd_timer *timer,
809 spin_lock_irqsave(&timer->lock, flags);
812 spin_unlock_irqrestore(&timer->lock, flags);
816 * timer work
821 struct snd_timer *timer = container_of(work, struct snd_timer, task_work);
824 if (timer->card && timer->card->shutdown) {
825 snd_timer_clear_callbacks(timer, &timer->sack_list_head);
829 spin_lock_irqsave(&timer->lock, flags);
830 snd_timer_process_callbacks(timer, &timer->sack_list_head);
831 spin_unlock_irqrestore(&timer->lock, flags);
835 * timer interrupt
837 * ticks_left is usually equal to timer->sticks.
840 void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left)
848 if (timer == NULL)
851 if (timer->card && timer->card->shutdown) {
852 snd_timer_clear_callbacks(timer, &timer->ack_list_head);
856 spin_lock_irqsave(&timer->lock, flags);
859 resolution = snd_timer_hw_resolution(timer);
866 list_for_each_entry_safe(ti, tmp, &timer->active_list_head,
884 --timer->running;
887 if ((timer->hw.flags & SNDRV_TIMER_HW_WORK) ||
889 ack_list_head = &timer->ack_list_head;
891 ack_list_head = &timer->sack_list_head;
901 if (timer->flags & SNDRV_TIMER_FLG_RESCHED)
902 snd_timer_reschedule(timer, timer->sticks);
903 if (timer->running) {
904 if (timer->hw.flags & SNDRV_TIMER_HW_STOP) {
905 timer->hw.stop(timer);
906 timer->flags |= SNDRV_TIMER_FLG_CHANGE;
908 if (!(timer->hw.flags & SNDRV_TIMER_HW_AUTO) ||
909 (timer->flags & SNDRV_TIMER_FLG_CHANGE)) {
910 /* restart timer */
911 timer->flags &= ~SNDRV_TIMER_FLG_CHANGE;
912 timer->hw.start(timer);
915 timer->hw.stop(timer);
919 snd_timer_process_callbacks(timer, &timer->ack_list_head);
922 use_work = !list_empty(&timer->sack_list_head);
923 spin_unlock_irqrestore(&timer->lock, flags);
926 queue_work(system_highpri_wq, &timer->task_work);
937 struct snd_timer *timer;
954 timer = kzalloc(sizeof(*timer), GFP_KERNEL);
955 if (!timer)
957 timer->tmr_class = tid->dev_class;
958 timer->card = card;
959 timer->tmr_device = tid->device;
960 timer->tmr_subdevice = tid->subdevice;
962 strlcpy(timer->id, id, sizeof(timer->id));
963 timer->sticks = 1;
964 INIT_LIST_HEAD(&timer->device_list);
965 INIT_LIST_HEAD(&timer->open_list_head);
966 INIT_LIST_HEAD(&timer->active_list_head);
967 INIT_LIST_HEAD(&timer->ack_list_head);
968 INIT_LIST_HEAD(&timer->sack_list_head);
969 spin_lock_init(&timer->lock);
970 INIT_WORK(&timer->task_work, snd_timer_work);
971 timer->max_instances = 1000; /* default limit per timer */
973 timer->module = card->module;
974 err = snd_device_new(card, SNDRV_DEV_TIMER, timer, &ops);
976 snd_timer_free(timer);
981 *rtimer = timer;
986 static int snd_timer_free(struct snd_timer *timer)
988 if (!timer)
992 if (! list_empty(&timer->open_list_head)) {
995 pr_warn("ALSA: timer %p is busy?\n", timer);
996 list_for_each_safe(p, n, &timer->open_list_head) {
999 ti->timer = NULL;
1002 list_del(&timer->device_list);
1005 if (timer->private_free)
1006 timer->private_free(timer);
1007 kfree(timer);
1013 struct snd_timer *timer = device->device_data;
1014 return snd_timer_free(timer);
1019 struct snd_timer *timer = dev->device_data;
1022 if (snd_BUG_ON(!timer || !timer->hw.start || !timer->hw.stop))
1024 if (!(timer->hw.flags & SNDRV_TIMER_HW_SLAVE) &&
1025 !timer->hw.resolution && timer->hw.c_resolution == NULL)
1030 if (timer1->tmr_class > timer->tmr_class)
1032 if (timer1->tmr_class < timer->tmr_class)
1034 if (timer1->card && timer->card) {
1035 if (timer1->card->number > timer->card->number)
1037 if (timer1->card->number < timer->card->number)
1040 if (timer1->tmr_device > timer->tmr_device)
1042 if (timer1->tmr_device < timer->tmr_device)
1044 if (timer1->tmr_subdevice > timer->tmr_subdevice)
1046 if (timer1->tmr_subdevice < timer->tmr_subdevice)
1052 list_add_tail(&timer->device_list, &timer1->device_list);
1059 struct snd_timer *timer = device->device_data;
1063 list_del_init(&timer->device_list);
1065 list_for_each_entry(ti, &timer->open_list_head, open_list) {
1073 void snd_timer_notify(struct snd_timer *timer, int event, struct timespec64 *tstamp)
1079 if (timer->card && timer->card->shutdown)
1081 if (! (timer->hw.flags & SNDRV_TIMER_HW_SLAVE))
1086 spin_lock_irqsave(&timer->lock, flags);
1090 resolution = snd_timer_hw_resolution(timer);
1091 list_for_each_entry(ti, &timer->active_list_head, active_list) {
1098 spin_unlock_irqrestore(&timer->lock, flags);
1118 int snd_timer_global_free(struct snd_timer *timer)
1120 return snd_timer_free(timer);
1124 int snd_timer_global_register(struct snd_timer *timer)
1129 dev.device_data = timer;
1135 * System timer
1150 struct snd_timer *timer = priv->snd_timer;
1154 snd_timer_interrupt(timer, (long)jiff - (long)priv->last_jiffies);
1157 static int snd_timer_s_start(struct snd_timer * timer)
1162 priv = (struct snd_timer_system_private *) timer->private_data;
1164 if (priv->correction > timer->sticks - 1) {
1165 priv->correction -= timer->sticks - 1;
1168 njiff += timer->sticks - priv->correction;
1176 static int snd_timer_s_stop(struct snd_timer * timer)
1181 priv = (struct snd_timer_system_private *) timer->private_data;
1185 timer->sticks = priv->last_expires - jiff;
1187 timer->sticks = 1;
1192 static int snd_timer_s_close(struct snd_timer *timer)
1196 priv = (struct snd_timer_system_private *)timer->private_data;
1211 static void snd_timer_free_system(struct snd_timer *timer)
1213 kfree(timer->private_data);
1218 struct snd_timer *timer;
1222 err = snd_timer_global_new("system", SNDRV_TIMER_GLOBAL_SYSTEM, &timer);
1225 strcpy(timer->name, "system timer");
1226 timer->hw = snd_timer_system;
1229 snd_timer_free(timer);
1232 priv->snd_timer = timer;
1234 timer->private_data = priv;
1235 timer->private_free = snd_timer_free_system;
1236 return snd_timer_global_register(timer);
1247 struct snd_timer *timer;
1251 list_for_each_entry(timer, &snd_timer_list, device_list) {
1252 if (timer->card && timer->card->shutdown)
1254 switch (timer->tmr_class) {
1256 snd_iprintf(buffer, "G%i: ", timer->tmr_device);
1260 timer->card->number, timer->tmr_device);
1263 snd_iprintf(buffer, "P%i-%i-%i: ", timer->card->number,
1264 timer->tmr_device, timer->tmr_subdevice);
1267 snd_iprintf(buffer, "?%i-%i-%i-%i: ", timer->tmr_class,
1268 timer->card ? timer->card->number : -1,
1269 timer->tmr_device, timer->tmr_subdevice);
1271 snd_iprintf(buffer, "%s :", timer->name);
1272 if (timer->hw.resolution)
1274 timer->hw.resolution / 1000,
1275 timer->hw.resolution % 1000,
1276 timer->hw.ticks);
1277 if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
1280 list_for_each_entry(ti, &timer->open_list_head, open_list)
1541 static void snd_timer_user_copy_id(struct snd_timer_id *id, struct snd_timer *timer)
1543 id->dev_class = timer->tmr_class;
1545 id->card = timer->card ? timer->card->number : -1;
1546 id->device = timer->tmr_device;
1547 id->subdevice = timer->tmr_subdevice;
1553 struct snd_timer *timer;
1563 timer = list_entry(snd_timer_list.next,
1565 snd_timer_user_copy_id(&id, timer);
1572 timer = list_entry(p, struct snd_timer, device_list);
1573 if (timer->tmr_class > SNDRV_TIMER_CLASS_GLOBAL) {
1574 snd_timer_user_copy_id(&id, timer);
1577 if (timer->tmr_device >= id.device) {
1578 snd_timer_user_copy_id(&id, timer);
1600 timer = list_entry(p, struct snd_timer, device_list);
1601 if (timer->tmr_class > id.dev_class) {
1602 snd_timer_user_copy_id(&id, timer);
1605 if (timer->tmr_class < id.dev_class)
1607 if (timer->card->number > id.card) {
1608 snd_timer_user_copy_id(&id, timer);
1611 if (timer->card->number < id.card)
1613 if (timer->tmr_device > id.device) {
1614 snd_timer_user_copy_id(&id, timer);
1617 if (timer->tmr_device < id.device)
1619 if (timer->tmr_subdevice > id.subdevice) {
1620 snd_timer_user_copy_id(&id, timer);
1623 if (timer->tmr_subdevice < id.subdevice)
1625 snd_timer_user_copy_id(&id, timer);
1808 t = tu->timeri->timer;
1838 t = tu->timeri->timer;
2013 /* start timer instead of continue if it's not used before */
2287 /* unregister the system timer */
2290 struct snd_timer *timer, *n;
2292 list_for_each_entry_safe(timer, n, &snd_timer_list, device_list)
2293 snd_timer_free(timer);
2307 dev_set_name(&timer_dev, "timer");
2311 "system timer");
2316 pr_err("ALSA: unable to register system timer (%i)\n", err);
2323 pr_err("ALSA: unable to register timer device (%i)\n", err);