[deliverable/linux.git] / sound / pci / ctxfi / 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 bool use_system_timer;
MODULE_PARM_DESC(use_system_timer, "Force 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;
	const 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 const 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 const 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) {
		dev_info(atc->card->dev, "Use xfi-native timer\n");
		atimer->ops = &ct_xfitimer_ops;
		hw->irq_callback_data = atimer;
		hw->irq_callback = ct_timer_interrupt;
	} else {
		dev_info(atc->card->dev, "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);
}
Commit	Line	Data
b7bbf876 TI	1	/*
	2	* PCM timer handling on ctxfi
	3	*
	4	* This source file is released under GPL v2 license (no other versions).
	5	* See the COPYING file included in the main directory of this source
	6	* distribution for the license terms and conditions.
	7	*/
	8
	9	#include <linux/slab.h>
28cd4aa4	10	#include <linux/math64.h>
04145f2b	11	#include <linux/moduleparam.h>
b7bbf876 TI	12	#include <sound/core.h>
	13	#include <sound/pcm.h>
	14	#include "ctatc.h"
	15	#include "cthardware.h"
	16	#include "cttimer.h"
	17
a67ff6a5 RR	18	static bool use_system_timer;
a67ff6a5 RR	19	MODULE_PARM_DESC(use_system_timer, "Force to use system-timer");
04145f2b TI	20	module_param(use_system_timer, bool, S_IRUGO);
04145f2b TI	21
b7bbf876 TI	22	struct ct_timer_ops {
	23	void (init)(struct ct_timer_instance );
	24	void (prepare)(struct ct_timer_instance );
	25	void (start)(struct ct_timer_instance );
	26	void (stop)(struct ct_timer_instance );
	27	void (free_instance)(struct ct_timer_instance );
	28	void (interrupt)(struct ct_timer );
	29	void (free_global)(struct ct_timer );
	30	};
	31
	32	/* timer instance -- assigned to each PCM stream */
	33	struct ct_timer_instance {
	34	spinlock_t lock;
	35	struct ct_timer *timer_base;
	36	struct ct_atc_pcm *apcm;
	37	struct snd_pcm_substream *substream;
	38	struct timer_list timer;
	39	struct list_head instance_list;
	40	struct list_head running_list;
	41	unsigned int position;
	42	unsigned int frag_count;
	43	unsigned int running:1;
	44	unsigned int need_update:1;
	45	};
	46
	47	/* timer instance manager */
	48	struct ct_timer {
	49	spinlock_t lock; /* global timer lock (for xfitimer) */
	50	spinlock_t list_lock; /* lock for instance list */
	51	struct ct_atc *atc;
53052393	52	const struct ct_timer_ops *ops;
b7bbf876 TI	53	struct list_head instance_head;
b7bbf876 TI	54	struct list_head running_head;
54de6bc8	55	unsigned int wc; /* current wallclock */
b7bbf876 TI	56	unsigned int irq_handling:1; /* in IRQ handling */
	57	unsigned int reprogram:1; /* need to reprogram the internval */
	58	unsigned int running:1; /* global timer running */
	59	};
	60
	61
	62	/*
	63	* system-timer-based updates
	64	*/
	65
	66	static void ct_systimer_callback(unsigned long data)
	67	{
	68	struct ct_timer_instance ti = (struct ct_timer_instance )data;
	69	struct snd_pcm_substream *substream = ti->substream;
	70	struct snd_pcm_runtime *runtime = substream->runtime;
	71	struct ct_atc_pcm *apcm = ti->apcm;
	72	unsigned int period_size = runtime->period_size;
	73	unsigned int buffer_size = runtime->buffer_size;
	74	unsigned long flags;
	75	unsigned int position, dist, interval;
	76
	77	position = substream->ops->pointer(substream);
	78	dist = (position + buffer_size - ti->position) % buffer_size;
	79	if (dist >= period_size \|\|
	80	position / period_size != ti->position / period_size) {
	81	apcm->interrupt(apcm);
	82	ti->position = position;
	83	}
	84	/* Add extra HZ*5/1000 to avoid overrun issue when recording
	85	* at 8kHz in 8-bit format or at 88kHz in 24-bit format. */
	86	interval = ((period_size - (position % period_size))
	87	* HZ + (runtime->rate - 1)) / runtime->rate + HZ * 5 / 1000;
	88	spin_lock_irqsave(&ti->lock, flags);
	89	if (ti->running)
	90	mod_timer(&ti->timer, jiffies + interval);
	91	spin_unlock_irqrestore(&ti->lock, flags);
	92	}
	93
	94	static void ct_systimer_init(struct ct_timer_instance *ti)
	95	{
	96	setup_timer(&ti->timer, ct_systimer_callback,
	97	(unsigned long)ti);
	98	}
	99
	100	static void ct_systimer_start(struct ct_timer_instance *ti)
	101	{
	102	struct snd_pcm_runtime *runtime = ti->substream->runtime;
	103	unsigned long flags;
	104
	105	spin_lock_irqsave(&ti->lock, flags);
	106	ti->running = 1;
	107	mod_timer(&ti->timer,
	108	jiffies + (runtime->period_size * HZ +
	109	(runtime->rate - 1)) / runtime->rate);
	110	spin_unlock_irqrestore(&ti->lock, flags);
	111	}
	112
	113	static void ct_systimer_stop(struct ct_timer_instance *ti)
	114	{
	115	unsigned long flags;
	116
	117	spin_lock_irqsave(&ti->lock, flags);
	118	ti->running = 0;
	119	del_timer(&ti->timer);
120	spin_unlock_irqrestore(&ti->lock, flags);
121	}
122
123	static void ct_systimer_prepare(struct ct_timer_instance *ti)
124	{
125	ct_systimer_stop(ti);
126	try_to_del_timer_sync(&ti->timer);
127	}
128
129	#define ct_systimer_free ct_systimer_prepare
130
53052393	131	static const struct ct_timer_ops ct_systimer_ops = {
b7bbf876 TI	132	.init = ct_systimer_init,
	133	.free_instance = ct_systimer_free,
	134	.prepare = ct_systimer_prepare,
	135	.start = ct_systimer_start,
	136	.stop = ct_systimer_stop,
	137	};
	138
	139
	140	/*
	141	* Handling multiple streams using a global emu20k1 timer irq
	142	*/
	143
	144	#define CT_TIMER_FREQ 48000
54de6bc8	145	#define MIN_TICKS 1
b7bbf876 TI	146	#define MAX_TICKS ((1 << 13) - 1)
	147
	148	static void ct_xfitimer_irq_rearm(struct ct_timer *atimer, int ticks)
	149	{
	150	struct hw *hw = atimer->atc->hw;
	151	if (ticks > MAX_TICKS)
	152	ticks = MAX_TICKS;
	153	hw->set_timer_tick(hw, ticks);
	154	if (!atimer->running)
	155	hw->set_timer_irq(hw, 1);
	156	atimer->running = 1;
	157	}
	158
	159	static void ct_xfitimer_irq_stop(struct ct_timer *atimer)
	160	{
	161	if (atimer->running) {
	162	struct hw *hw = atimer->atc->hw;
	163	hw->set_timer_irq(hw, 0);
	164	hw->set_timer_tick(hw, 0);
	165	atimer->running = 0;
	166	}
	167	}
	168
54de6bc8 TI	169	static inline unsigned int ct_xfitimer_get_wc(struct ct_timer *atimer)
	170	{
	171	struct hw *hw = atimer->atc->hw;
	172	return hw->get_wc(hw);
	173	}
	174
b7bbf876 TI	175	/*
	176	* reprogram the timer interval;
	177	* checks the running instance list and determines the next timer interval.
	178	* also updates the each stream position, returns the number of streams
	179	* to call snd_pcm_period_elapsed() appropriately
	180	*
	181	* call this inside the lock and irq disabled
	182	*/
8dca4197	183	static int ct_xfitimer_reprogram(struct ct_timer *atimer, int can_update)
b7bbf876 TI	184	{
b7bbf876 TI	185	struct ct_timer_instance *ti;
54de6bc8	186	unsigned int min_intr = (unsigned int)-1;
b7bbf876	187	int updates = 0;
54de6bc8	188	unsigned int wc, diff;
b7bbf876	189
54de6bc8 TI	190	if (list_empty(&atimer->running_head)) {
	191	ct_xfitimer_irq_stop(atimer);
	192	atimer->reprogram = 0; /* clear flag */
	193	return 0;
	194	}
	195
	196	wc = ct_xfitimer_get_wc(atimer);
	197	diff = wc - atimer->wc;
	198	atimer->wc = wc;
b7bbf876	199	list_for_each_entry(ti, &atimer->running_head, running_list) {
54de6bc8 TI	200	if (ti->frag_count > diff)
	201	ti->frag_count -= diff;
	202	else {
	203	unsigned int pos;
	204	unsigned int period_size, rate;
	205
	206	period_size = ti->substream->runtime->period_size;
	207	rate = ti->substream->runtime->rate;
	208	pos = ti->substream->ops->pointer(ti->substream);
	209	if (pos / period_size != ti->position / period_size) {
	210	ti->need_update = 1;
	211	ti->position = pos;
	212	updates++;
	213	}
	214	pos %= period_size;
	215	pos = period_size - pos;
	216	ti->frag_count = div_u64((u64)pos * CT_TIMER_FREQ +
	217	rate - 1, rate);
b7bbf876	218	}
8dca4197 TI	219	if (ti->need_update && !can_update)
8dca4197 TI	220	min_intr = 0; /* pending to the next irq */
54de6bc8 TI	221	if (ti->frag_count < min_intr)
54de6bc8 TI	222	min_intr = ti->frag_count;
b7bbf876 TI	223	}
b7bbf876 TI	224
54de6bc8 TI	225	if (min_intr < MIN_TICKS)
	226	min_intr = MIN_TICKS;
	227	ct_xfitimer_irq_rearm(atimer, min_intr);
b7bbf876 TI	228	atimer->reprogram = 0; /* clear flag */
	229	return updates;
	230	}
	231
	232	/* look through the instance list and call period_elapsed if needed */
	233	static void ct_xfitimer_check_period(struct ct_timer *atimer)
	234	{
	235	struct ct_timer_instance *ti;
	236	unsigned long flags;
	237
	238	spin_lock_irqsave(&atimer->list_lock, flags);
	239	list_for_each_entry(ti, &atimer->instance_head, instance_list) {
8dca4197	240	if (ti->running && ti->need_update) {
b7bbf876 TI	241	ti->need_update = 0;
	242	ti->apcm->interrupt(ti->apcm);
	243	}
	244	}
	245	spin_unlock_irqrestore(&atimer->list_lock, flags);
	246	}
	247
	248	/* Handle timer-interrupt */
	249	static void ct_xfitimer_callback(struct ct_timer *atimer)
	250	{
	251	int update;
	252	unsigned long flags;
	253
	254	spin_lock_irqsave(&atimer->lock, flags);
	255	atimer->irq_handling = 1;
	256	do {
8dca4197	257	update = ct_xfitimer_reprogram(atimer, 1);
b7bbf876 TI	258	spin_unlock(&atimer->lock);
	259	if (update)
	260	ct_xfitimer_check_period(atimer);
	261	spin_lock(&atimer->lock);
	262	} while (atimer->reprogram);
	263	atimer->irq_handling = 0;
	264	spin_unlock_irqrestore(&atimer->lock, flags);
	265	}
	266
	267	static void ct_xfitimer_prepare(struct ct_timer_instance *ti)
	268	{
	269	ti->frag_count = ti->substream->runtime->period_size;
8dca4197	270	ti->running = 0;
b7bbf876 TI	271	ti->need_update = 0;
	272	}
	273
	274
	275	/* start/stop the timer */
	276	static void ct_xfitimer_update(struct ct_timer *atimer)
	277	{
	278	unsigned long flags;
b7bbf876	279
54de6bc8	280	spin_lock_irqsave(&atimer->lock, flags);
b7bbf876 TI	281	if (atimer->irq_handling) {
	282	/* reached from IRQ handler; let it handle later */
	283	atimer->reprogram = 1;
54de6bc8	284	spin_unlock_irqrestore(&atimer->lock, flags);
b7bbf876 TI	285	return;
	286	}
	287
b7bbf876	288	ct_xfitimer_irq_stop(atimer);
8dca4197	289	ct_xfitimer_reprogram(atimer, 0);
b7bbf876	290	spin_unlock_irqrestore(&atimer->lock, flags);
b7bbf876 TI	291	}
	292
	293	static void ct_xfitimer_start(struct ct_timer_instance *ti)
	294	{
	295	struct ct_timer *atimer = ti->timer_base;
	296	unsigned long flags;
	297
	298	spin_lock_irqsave(&atimer->lock, flags);
54de6bc8 TI	299	if (list_empty(&ti->running_list))
54de6bc8 TI	300	atimer->wc = ct_xfitimer_get_wc(atimer);
8dca4197 TI	301	ti->running = 1;
8dca4197 TI	302	ti->need_update = 0;
b7bbf876 TI	303	list_add(&ti->running_list, &atimer->running_head);
	304	spin_unlock_irqrestore(&atimer->lock, flags);
	305	ct_xfitimer_update(atimer);
	306	}
	307
	308	static void ct_xfitimer_stop(struct ct_timer_instance *ti)
	309	{
	310	struct ct_timer *atimer = ti->timer_base;
	311	unsigned long flags;
	312
	313	spin_lock_irqsave(&atimer->lock, flags);
	314	list_del_init(&ti->running_list);
8dca4197	315	ti->running = 0;
b7bbf876 TI	316	spin_unlock_irqrestore(&atimer->lock, flags);
	317	ct_xfitimer_update(atimer);
	318	}
	319
	320	static void ct_xfitimer_free_global(struct ct_timer *atimer)
	321	{
	322	ct_xfitimer_irq_stop(atimer);
	323	}
	324
53052393	325	static const struct ct_timer_ops ct_xfitimer_ops = {
b7bbf876 TI	326	.prepare = ct_xfitimer_prepare,
	327	.start = ct_xfitimer_start,
	328	.stop = ct_xfitimer_stop,
	329	.interrupt = ct_xfitimer_callback,
	330	.free_global = ct_xfitimer_free_global,
	331	};
	332
	333	/*
	334	* timer instance
	335	*/
	336
	337	struct ct_timer_instance *
	338	ct_timer_instance_new(struct ct_timer atimer, struct ct_atc_pcm apcm)
	339	{
	340	struct ct_timer_instance *ti;
	341
	342	ti = kzalloc(sizeof(*ti), GFP_KERNEL);
	343	if (!ti)
	344	return NULL;
	345	spin_lock_init(&ti->lock);
	346	INIT_LIST_HEAD(&ti->instance_list);
	347	INIT_LIST_HEAD(&ti->running_list);
	348	ti->timer_base = atimer;
	349	ti->apcm = apcm;
	350	ti->substream = apcm->substream;
	351	if (atimer->ops->init)
	352	atimer->ops->init(ti);
	353
	354	spin_lock_irq(&atimer->list_lock);
	355	list_add(&ti->instance_list, &atimer->instance_head);
	356	spin_unlock_irq(&atimer->list_lock);
	357
	358	return ti;
	359	}
	360
	361	void ct_timer_prepare(struct ct_timer_instance *ti)
	362	{
	363	if (ti->timer_base->ops->prepare)
	364	ti->timer_base->ops->prepare(ti);
	365	ti->position = 0;
	366	ti->running = 0;
	367	}
	368
	369	void ct_timer_start(struct ct_timer_instance *ti)
	370	{
	371	struct ct_timer *atimer = ti->timer_base;
	372	atimer->ops->start(ti);
	373	}
	374
	375	void ct_timer_stop(struct ct_timer_instance *ti)
	376	{
	377	struct ct_timer *atimer = ti->timer_base;
	378	atimer->ops->stop(ti);
	379	}
	380
	381	void ct_timer_instance_free(struct ct_timer_instance *ti)
	382	{
	383	struct ct_timer *atimer = ti->timer_base;
	384
	385	atimer->ops->stop(ti); /* to be sure */
	386	if (atimer->ops->free_instance)
	387	atimer->ops->free_instance(ti);
	388
	389	spin_lock_irq(&atimer->list_lock);
390	list_del(&ti->instance_list);
391	spin_unlock_irq(&atimer->list_lock);
392
393	kfree(ti);
394	}
395
396	/*
397	* timer manager
398	*/
399
b7bbf876 TI	400	static void ct_timer_interrupt(void *data, unsigned int status)
	401	{
	402	struct ct_timer *timer = data;
	403
	404	/* Interval timer interrupt */
	405	if ((status & IT_INT) && timer->ops->interrupt)
	406	timer->ops->interrupt(timer);
	407	}
	408
	409	struct ct_timer ct_timer_new(struct ct_atc atc)
	410	{
	411	struct ct_timer *atimer;
	412	struct hw *hw;
	413
	414	atimer = kzalloc(sizeof(*atimer), GFP_KERNEL);
	415	if (!atimer)
	416	return NULL;
	417	spin_lock_init(&atimer->lock);
	418	spin_lock_init(&atimer->list_lock);
	419	INIT_LIST_HEAD(&atimer->instance_head);
	420	INIT_LIST_HEAD(&atimer->running_head);
	421	atimer->atc = atc;
	422	hw = atc->hw;
04145f2b	423	if (!use_system_timer && hw->set_timer_irq) {
2e6705c0	424	dev_info(atc->card->dev, "Use xfi-native timer\n");
b7bbf876 TI	425	atimer->ops = &ct_xfitimer_ops;
	426	hw->irq_callback_data = atimer;
	427	hw->irq_callback = ct_timer_interrupt;
	428	} else {
2e6705c0	429	dev_info(atc->card->dev, "Use system timer\n");
b7bbf876 TI	430	atimer->ops = &ct_systimer_ops;
	431	}
	432	return atimer;
	433	}
	434
	435	void ct_timer_free(struct ct_timer *atimer)
	436	{
	437	struct hw *hw = atimer->atc->hw;
	438	hw->irq_callback = NULL;
	439	if (atimer->ops->free_global)
	440	atimer->ops->free_global(atimer);
	441	kfree(atimer);
	442	}
	443