Logo Search packages:      
Sourcecode: alsa-driver version File versions

cttimer.c

/*
 * PCM timer handling on ctxfi
 *
 * This source file is released under GPL v2 license (no other versions).
 * See the COPYING file included in the main directory of this source
 * distribution for the license terms and conditions.
 */

#include <linux/slab.h>
#include <linux/math64.h>
#include <linux/moduleparam.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include "ctatc.h"
#include "cthardware.h"
#include "cttimer.h"

static int use_system_timer;
MODULE_PARM_DESC(use_system_timer, "Foce to use system-timer");
module_param(use_system_timer, bool, S_IRUGO);

struct ct_timer_ops {
      void (*init)(struct ct_timer_instance *);
      void (*prepare)(struct ct_timer_instance *);
      void (*start)(struct ct_timer_instance *);
      void (*stop)(struct ct_timer_instance *);
      void (*free_instance)(struct ct_timer_instance *);
      void (*interrupt)(struct ct_timer *);
      void (*free_global)(struct ct_timer *);
};

/* timer instance -- assigned to each PCM stream */
struct ct_timer_instance {
      spinlock_t lock;
      struct ct_timer *timer_base;
      struct ct_atc_pcm *apcm;
      struct snd_pcm_substream *substream;
      struct timer_list timer;
      struct list_head instance_list;
      struct list_head running_list;
      unsigned int position;
      unsigned int frag_count;
      unsigned int running:1;
      unsigned int need_update:1;
};

/* timer instance manager */
struct ct_timer {
      spinlock_t lock;        /* global timer lock (for xfitimer) */
      spinlock_t list_lock;         /* lock for instance list */
      struct ct_atc *atc;
      struct ct_timer_ops *ops;
      struct list_head instance_head;
      struct list_head running_head;
      unsigned int wc;        /* current wallclock */
      unsigned int irq_handling:1;  /* in IRQ handling */
      unsigned int reprogram:1;     /* need to reprogram the internval */
      unsigned int running:1;       /* global timer running */
};


/*
 * system-timer-based updates
 */

static void ct_systimer_callback(unsigned long data)
{
      struct ct_timer_instance *ti = (struct ct_timer_instance *)data;
      struct snd_pcm_substream *substream = ti->substream;
      struct snd_pcm_runtime *runtime = substream->runtime;
      struct ct_atc_pcm *apcm = ti->apcm;
      unsigned int period_size = runtime->period_size;
      unsigned int buffer_size = runtime->buffer_size;
      unsigned long flags;
      unsigned int position, dist, interval;

      position = substream->ops->pointer(substream);
      dist = (position + buffer_size - ti->position) % buffer_size;
      if (dist >= period_size ||
          position / period_size != ti->position / period_size) {
            apcm->interrupt(apcm);
            ti->position = position;
      }
      /* Add extra HZ*5/1000 to avoid overrun issue when recording
       * at 8kHz in 8-bit format or at 88kHz in 24-bit format. */
      interval = ((period_size - (position % period_size))
               * HZ + (runtime->rate - 1)) / runtime->rate + HZ * 5 / 1000;
      spin_lock_irqsave(&ti->lock, flags);
      if (ti->running)
            mod_timer(&ti->timer, jiffies + interval);
      spin_unlock_irqrestore(&ti->lock, flags);
}

static void ct_systimer_init(struct ct_timer_instance *ti)
{
      setup_timer(&ti->timer, ct_systimer_callback,
                (unsigned long)ti);
}

static void ct_systimer_start(struct ct_timer_instance *ti)
{
      struct snd_pcm_runtime *runtime = ti->substream->runtime;
      unsigned long flags;

      spin_lock_irqsave(&ti->lock, flags);
      ti->running = 1;
      mod_timer(&ti->timer,
              jiffies + (runtime->period_size * HZ +
                       (runtime->rate - 1)) / runtime->rate);
      spin_unlock_irqrestore(&ti->lock, flags);
}

static void ct_systimer_stop(struct ct_timer_instance *ti)
{
      unsigned long flags;

      spin_lock_irqsave(&ti->lock, flags);
      ti->running = 0;
      del_timer(&ti->timer);
      spin_unlock_irqrestore(&ti->lock, flags);
}

static void ct_systimer_prepare(struct ct_timer_instance *ti)
{
      ct_systimer_stop(ti);
      try_to_del_timer_sync(&ti->timer);
}

#define ct_systimer_free      ct_systimer_prepare

static struct ct_timer_ops ct_systimer_ops = {
      .init = ct_systimer_init,
      .free_instance = ct_systimer_free,
      .prepare = ct_systimer_prepare,
      .start = ct_systimer_start,
      .stop = ct_systimer_stop,
};


/*
 * Handling multiple streams using a global emu20k1 timer irq
 */

#define CT_TIMER_FREQ   48000
#define MIN_TICKS 1
#define MAX_TICKS ((1 << 13) - 1)

static void ct_xfitimer_irq_rearm(struct ct_timer *atimer, int ticks)
{
      struct hw *hw = atimer->atc->hw;
      if (ticks > MAX_TICKS)
            ticks = MAX_TICKS;
      hw->set_timer_tick(hw, ticks);
      if (!atimer->running)
            hw->set_timer_irq(hw, 1);
      atimer->running = 1;
}

static void ct_xfitimer_irq_stop(struct ct_timer *atimer)
{
      if (atimer->running) {
            struct hw *hw = atimer->atc->hw;
            hw->set_timer_irq(hw, 0);
            hw->set_timer_tick(hw, 0);
            atimer->running = 0;
      }
}

static inline unsigned int ct_xfitimer_get_wc(struct ct_timer *atimer)
{
      struct hw *hw = atimer->atc->hw;
      return hw->get_wc(hw);
}

/*
 * reprogram the timer interval;
 * checks the running instance list and determines the next timer interval.
 * also updates the each stream position, returns the number of streams
 * to call snd_pcm_period_elapsed() appropriately
 *
 * call this inside the lock and irq disabled
 */
static int ct_xfitimer_reprogram(struct ct_timer *atimer, int can_update)
{
      struct ct_timer_instance *ti;
      unsigned int min_intr = (unsigned int)-1;
      int updates = 0;
      unsigned int wc, diff;

      if (list_empty(&atimer->running_head)) {
            ct_xfitimer_irq_stop(atimer);
            atimer->reprogram = 0; /* clear flag */
            return 0;
      }

      wc = ct_xfitimer_get_wc(atimer);
      diff = wc - atimer->wc;
      atimer->wc = wc;
      list_for_each_entry(ti, &atimer->running_head, running_list) {
            if (ti->frag_count > diff)
                  ti->frag_count -= diff;
            else {
                  unsigned int pos;
                  unsigned int period_size, rate;

                  period_size = ti->substream->runtime->period_size;
                  rate = ti->substream->runtime->rate;
                  pos = ti->substream->ops->pointer(ti->substream);
                  if (pos / period_size != ti->position / period_size) {
                        ti->need_update = 1;
                        ti->position = pos;
                        updates++;
                  }
                  pos %= period_size;
                  pos = period_size - pos;
                  ti->frag_count = div_u64((u64)pos * CT_TIMER_FREQ +
                                     rate - 1, rate);
            }
            if (ti->need_update && !can_update)
                  min_intr = 0; /* pending to the next irq */
            if (ti->frag_count < min_intr)
                  min_intr = ti->frag_count;
      }

      if (min_intr < MIN_TICKS)
            min_intr = MIN_TICKS;
      ct_xfitimer_irq_rearm(atimer, min_intr);
      atimer->reprogram = 0; /* clear flag */
      return updates;
}

/* look through the instance list and call period_elapsed if needed */
static void ct_xfitimer_check_period(struct ct_timer *atimer)
{
      struct ct_timer_instance *ti;
      unsigned long flags;

      spin_lock_irqsave(&atimer->list_lock, flags);
      list_for_each_entry(ti, &atimer->instance_head, instance_list) {
            if (ti->running && ti->need_update) {
                  ti->need_update = 0;
                  ti->apcm->interrupt(ti->apcm);
            }
      }
      spin_unlock_irqrestore(&atimer->list_lock, flags);
}

/* Handle timer-interrupt */
static void ct_xfitimer_callback(struct ct_timer *atimer)
{
      int update;
      unsigned long flags;

      spin_lock_irqsave(&atimer->lock, flags);
      atimer->irq_handling = 1;
      do {
            update = ct_xfitimer_reprogram(atimer, 1);
            spin_unlock(&atimer->lock);
            if (update)
                  ct_xfitimer_check_period(atimer);
            spin_lock(&atimer->lock);
      } while (atimer->reprogram);
      atimer->irq_handling = 0;
      spin_unlock_irqrestore(&atimer->lock, flags);
}

static void ct_xfitimer_prepare(struct ct_timer_instance *ti)
{
      ti->frag_count = ti->substream->runtime->period_size;
      ti->running = 0;
      ti->need_update = 0;
}


/* start/stop the timer */
static void ct_xfitimer_update(struct ct_timer *atimer)
{
      unsigned long flags;

      spin_lock_irqsave(&atimer->lock, flags);
      if (atimer->irq_handling) {
            /* reached from IRQ handler; let it handle later */
            atimer->reprogram = 1;
            spin_unlock_irqrestore(&atimer->lock, flags);
            return;
      }

      ct_xfitimer_irq_stop(atimer);
      ct_xfitimer_reprogram(atimer, 0);
      spin_unlock_irqrestore(&atimer->lock, flags);
}

static void ct_xfitimer_start(struct ct_timer_instance *ti)
{
      struct ct_timer *atimer = ti->timer_base;
      unsigned long flags;

      spin_lock_irqsave(&atimer->lock, flags);
      if (list_empty(&ti->running_list))
            atimer->wc = ct_xfitimer_get_wc(atimer);
      ti->running = 1;
      ti->need_update = 0;
      list_add(&ti->running_list, &atimer->running_head);
      spin_unlock_irqrestore(&atimer->lock, flags);
      ct_xfitimer_update(atimer);
}

static void ct_xfitimer_stop(struct ct_timer_instance *ti)
{
      struct ct_timer *atimer = ti->timer_base;
      unsigned long flags;

      spin_lock_irqsave(&atimer->lock, flags);
      list_del_init(&ti->running_list);
      ti->running = 0;
      spin_unlock_irqrestore(&atimer->lock, flags);
      ct_xfitimer_update(atimer);
}

static void ct_xfitimer_free_global(struct ct_timer *atimer)
{
      ct_xfitimer_irq_stop(atimer);
}

static struct ct_timer_ops ct_xfitimer_ops = {
      .prepare = ct_xfitimer_prepare,
      .start = ct_xfitimer_start,
      .stop = ct_xfitimer_stop,
      .interrupt = ct_xfitimer_callback,
      .free_global = ct_xfitimer_free_global,
};

/*
 * timer instance
 */

struct ct_timer_instance *
ct_timer_instance_new(struct ct_timer *atimer, struct ct_atc_pcm *apcm)
{
      struct ct_timer_instance *ti;

      ti = kzalloc(sizeof(*ti), GFP_KERNEL);
      if (!ti)
            return NULL;
      spin_lock_init(&ti->lock);
      INIT_LIST_HEAD(&ti->instance_list);
      INIT_LIST_HEAD(&ti->running_list);
      ti->timer_base = atimer;
      ti->apcm = apcm;
      ti->substream = apcm->substream;
      if (atimer->ops->init)
            atimer->ops->init(ti);

      spin_lock_irq(&atimer->list_lock);
      list_add(&ti->instance_list, &atimer->instance_head);
      spin_unlock_irq(&atimer->list_lock);

      return ti;
}

void ct_timer_prepare(struct ct_timer_instance *ti)
{
      if (ti->timer_base->ops->prepare)
            ti->timer_base->ops->prepare(ti);
      ti->position = 0;
      ti->running = 0;
}

void ct_timer_start(struct ct_timer_instance *ti)
{
      struct ct_timer *atimer = ti->timer_base;
      atimer->ops->start(ti);
}

void ct_timer_stop(struct ct_timer_instance *ti)
{
      struct ct_timer *atimer = ti->timer_base;
      atimer->ops->stop(ti);
}

void ct_timer_instance_free(struct ct_timer_instance *ti)
{
      struct ct_timer *atimer = ti->timer_base;

      atimer->ops->stop(ti); /* to be sure */
      if (atimer->ops->free_instance)
            atimer->ops->free_instance(ti);

      spin_lock_irq(&atimer->list_lock);
      list_del(&ti->instance_list);
      spin_unlock_irq(&atimer->list_lock);

      kfree(ti);
}

/*
 * timer manager
 */

static void ct_timer_interrupt(void *data, unsigned int status)
{
      struct ct_timer *timer = data;

      /* Interval timer interrupt */
      if ((status & IT_INT) && timer->ops->interrupt)
            timer->ops->interrupt(timer);
}

struct ct_timer *ct_timer_new(struct ct_atc *atc)
{
      struct ct_timer *atimer;
      struct hw *hw;

      atimer = kzalloc(sizeof(*atimer), GFP_KERNEL);
      if (!atimer)
            return NULL;
      spin_lock_init(&atimer->lock);
      spin_lock_init(&atimer->list_lock);
      INIT_LIST_HEAD(&atimer->instance_head);
      INIT_LIST_HEAD(&atimer->running_head);
      atimer->atc = atc;
      hw = atc->hw;
      if (!use_system_timer && hw->set_timer_irq) {
            snd_printd(KERN_INFO "ctxfi: Use xfi-native timer\n");
            atimer->ops = &ct_xfitimer_ops;
            hw->irq_callback_data = atimer;
            hw->irq_callback = ct_timer_interrupt;
      } else {
            snd_printd(KERN_INFO "ctxfi: Use system timer\n");
            atimer->ops = &ct_systimer_ops;
      }
      return atimer;
}

void ct_timer_free(struct ct_timer *atimer)
{
      struct hw *hw = atimer->atc->hw;
      hw->irq_callback = NULL;
      if (atimer->ops->free_global)
            atimer->ops->free_global(atimer);
      kfree(atimer);
}


Generated by  Doxygen 1.6.0   Back to index