sound/core/hrtimer.c

   1 /*
   2  * ALSA timer back-end using hrtimer
   3  * Copyright (C) 2008 Takashi Iwai
   4  *
   5  *   This program is free software; you can redistribute it and/or modify
   6  *   it under the terms of the GNU General Public License as published by
   7  *   the Free Software Foundation; either version 2 of the License, or
   8  *   (at your option) any later version.
   9  *
  10  *   This program is distributed in the hope that it will be useful,
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *   GNU General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program; if not, write to the Free Software
  17  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18  *
  19  */
  20
  21 #include <linux/init.h>
  22 #include <linux/slab.h>
  23 #include <linux/module.h>
  24 #include <linux/moduleparam.h>
  25 #include <linux/hrtimer.h>
  26 #include <sound/core.h>
  27 #include <sound/timer.h>
  28
  29 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
  30 MODULE_DESCRIPTION("ALSA hrtimer backend");
  31 MODULE_LICENSE("GPL");
  32
  33 MODULE_ALIAS("snd-timer-" __stringify(SNDRV_TIMER_GLOBAL_HRTIMER));
  34
  35 #define NANO_SEC        1000000000UL    /* 10^9 in sec */
  36 static unsigned int resolution;
  37
  38 struct snd_hrtimer {
  39         struct snd_timer *timer;
  40         struct hrtimer hrt;
  41         bool in_callback;
  42 };
  43
  44 static enum hrtimer_restart snd_hrtimer_callback(struct hrtimer *hrt)
  45 {
  46         struct snd_hrtimer *stime = container_of(hrt, struct snd_hrtimer, hrt);
  47         struct snd_timer *t = stime->timer;
  48         ktime_t delta;
  49         unsigned long ticks;
  50         enum hrtimer_restart ret = HRTIMER_NORESTART;
  51
  52         spin_lock(&t->lock);
  53         if (!t->running)
  54                 goto out; /* fast path */
  55         stime->in_callback = true;
  56         ticks = t->sticks;
  57         spin_unlock(&t->lock);
  58
  59         /* calculate the drift */
  60         delta = ktime_sub(hrt->base->get_time(), hrtimer_get_expires(hrt));
  61         if (delta > 0)
  62                 ticks += ktime_divns(delta, ticks * resolution);
  63
  64         snd_timer_interrupt(stime->timer, ticks);
  65
  66         spin_lock(&t->lock);
  67         if (t->running) {
  68                 hrtimer_add_expires_ns(hrt, t->sticks * resolution);
  69                 ret = HRTIMER_RESTART;
  70         }
  71
  72         stime->in_callback = false;
  73  out:
  74         spin_unlock(&t->lock);
  75         return ret;
  76 }
  77
  78 static int snd_hrtimer_open(struct snd_timer *t)
  79 {
  80         struct snd_hrtimer *stime;
  81
  82         stime = kzalloc(sizeof(*stime), GFP_KERNEL);
  83         if (!stime)
  84                 return -ENOMEM;
  85         hrtimer_init(&stime->hrt, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
  86         stime->timer = t;
  87         stime->hrt.function = snd_hrtimer_callback;
  88         t->private_data = stime;
  89         return 0;
  90 }
  91
  92 static int snd_hrtimer_close(struct snd_timer *t)
  93 {
  94         struct snd_hrtimer *stime = t->private_data;
  95
  96         if (stime) {
  97                 spin_lock_irq(&t->lock);
  98                 t->running = 0; /* just to be sure */
  99                 stime->in_callback = 1; /* skip start/stop */
 100                 spin_unlock_irq(&t->lock);
 101
 102                 hrtimer_cancel(&stime->hrt);
 103                 kfree(stime);
 104                 t->private_data = NULL;
 105         }
 106         return 0;
 107 }
 108
 109 static int snd_hrtimer_start(struct snd_timer *t)
 110 {
 111         struct snd_hrtimer *stime = t->private_data;
 112
 113         if (stime->in_callback)
 114                 return 0;
 115         hrtimer_start(&stime->hrt, ns_to_ktime(t->sticks * resolution),
 116                       HRTIMER_MODE_REL);
 117         return 0;
 118 }
 119
 120 static int snd_hrtimer_stop(struct snd_timer *t)
 121 {
 122         struct snd_hrtimer *stime = t->private_data;
 123
 124         if (stime->in_callback)
 125                 return 0;
 126         hrtimer_try_to_cancel(&stime->hrt);
 127         return 0;
 128 }
 129
 130 static const struct snd_timer_hardware hrtimer_hw __initconst = {
 131         .flags =        SNDRV_TIMER_HW_AUTO | SNDRV_TIMER_HW_TASKLET,
 132         .open =         snd_hrtimer_open,
 133         .close =        snd_hrtimer_close,
 134         .start =        snd_hrtimer_start,
 135         .stop =         snd_hrtimer_stop,
 136 };
 137
 138 /*
 139  * entry functions
 140  */
 141
 142 static struct snd_timer *mytimer;
 143
 144 static int __init snd_hrtimer_init(void)
 145 {
 146         struct snd_timer *timer;
 147         int err;
 148
 149         resolution = hrtimer_resolution;
 150
 151         /* Create a new timer and set up the fields */
 152         err = snd_timer_global_new("hrtimer", SNDRV_TIMER_GLOBAL_HRTIMER,
 153                                    &timer);
 154         if (err < 0)
 155                 return err;
 156
 157         timer->module = THIS_MODULE;
 158         strcpy(timer->name, "HR timer");
 159         timer->hw = hrtimer_hw;
 160         timer->hw.resolution = resolution;
 161         timer->hw.ticks = NANO_SEC / resolution;
 162         timer->max_instances = 100; /* lower the limit */
 163
 164         err = snd_timer_global_register(timer);
 165         if (err < 0) {
 166                 snd_timer_global_free(timer);
 167                 return err;
 168         }
 169         mytimer = timer; /* remember this */
 170
 171         return 0;
 172 }
 173
 174 static void __exit snd_hrtimer_exit(void)
 175 {
 176         if (mytimer) {
 177                 snd_timer_global_free(mytimer);
 178                 mytimer = NULL;
 179         }
 180 }
 181
 182 module_init(snd_hrtimer_init);
 183 module_exit(snd_hrtimer_exit);