Subversion Repositories or1k

 
/*
 **********************************************************************
 *     timer.c
 *     Copyright (C) 1999, 2000 Creative Labs, inc.
 *
 **********************************************************************
 *
 *     This program is free software; you can redistribute it and/or
 *     modify it under the terms of the GNU General Public License as
 *     published by the Free Software Foundation; either version 2 of
 *     the License, or (at your option) any later version.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public
 *     License along with this program; if not, write to the Free
 *     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
 *     USA.
 *
 **********************************************************************
 */
 
/* 3/6/2000	Improved support for different timer delays  Rui Sousa */
 
/* 4/3/2000	Implemented timer list using list.h 	     Rui Sousa */
 
#include "hwaccess.h"
#include "8010.h"
#include "irqmgr.h"
#include "timer.h"
 
/* Try to schedule only once per fragment */
 
void emu10k1_timer_irqhandler(struct emu10k1_card *card)
{
	struct emu_timer *t;
	struct list_head *entry;
 
	spin_lock(&card->timer_lock);
 
	list_for_each(entry, &card->timers) {
		t = list_entry(entry, struct emu_timer, list);
 
		if (t->state & TIMER_STATE_ACTIVE) {
			t->count++;
			if (t->count == t->count_max) {
				t->count = 0;
				tasklet_hi_schedule(&t->tasklet);
			}
		}
	}
 
	spin_unlock(&card->timer_lock);
 
	return;
}
 
void emu10k1_timer_install(struct emu10k1_card *card, struct emu_timer *timer, u16 delay)
{
	struct emu_timer *t;
	struct list_head *entry;
	unsigned long flags;
 
	if (delay < 5)
		delay = 5;
 
	timer->delay = delay;
	timer->state = TIMER_STATE_INSTALLED;
 
	spin_lock_irqsave(&card->timer_lock, flags);
 
	timer->count_max = timer->delay / (card->timer_delay < 1024 ? card->timer_delay : 1024);
	timer->count = timer->count_max - 1;
 
	list_add(&timer->list, &card->timers);
 
	if (card->timer_delay > delay) {
		if (card->timer_delay == TIMER_STOPPED)
			emu10k1_irq_enable(card, INTE_INTERVALTIMERENB);
 
		card->timer_delay = delay;
		delay = (delay < 1024 ? delay : 1024);
 
		emu10k1_timer_set(card, delay);
 
		list_for_each(entry, &card->timers) {
			t = list_entry(entry, struct emu_timer, list);
 
			t->count_max = t->delay / delay;
			/* don't want to think much, just force scheduling 
			   on the next interrupt */
			t->count = t->count_max - 1;
		}
 
		DPD(2, "timer rate --> %u\n", delay);
	}
 
	spin_unlock_irqrestore(&card->timer_lock, flags);
 
	return;
}
 
void emu10k1_timer_uninstall(struct emu10k1_card *card, struct emu_timer *timer)
{
	struct emu_timer *t;
	struct list_head *entry;
	u16 delay = TIMER_STOPPED;
	unsigned long flags;
 
	if (timer->state == TIMER_STATE_UNINSTALLED)
		return;
 
	spin_lock_irqsave(&card->timer_lock, flags);
 
	list_del(&timer->list);
 
	list_for_each(entry, &card->timers) {
		t = list_entry(entry, struct emu_timer, list);
 
		if (t->delay < delay)
			delay = t->delay;
	}
 
	if (card->timer_delay != delay) {
		card->timer_delay = delay;
 
		if (delay == TIMER_STOPPED)
			emu10k1_irq_disable(card, INTE_INTERVALTIMERENB);
		else {
			delay = (delay < 1024 ? delay : 1024);
 
			emu10k1_timer_set(card, delay);
 
			list_for_each(entry, &card->timers) {
				t = list_entry(entry, struct emu_timer, list);
 
				t->count_max = t->delay / delay;
				t->count = t->count_max - 1;
			}
		}
 
		DPD(2, "timer rate --> %u\n", delay);
	}
 
	spin_unlock_irqrestore(&card->timer_lock, flags);
 
	timer->state = TIMER_STATE_UNINSTALLED;
 
	return;
}
 
void emu10k1_timer_enable(struct emu10k1_card *card, struct emu_timer *timer)
{
	unsigned long flags;
 
	spin_lock_irqsave(&card->timer_lock, flags);
	timer->state |= TIMER_STATE_ACTIVE;
	spin_unlock_irqrestore(&card->timer_lock, flags);
 
	return;
}
 
void emu10k1_timer_disable(struct emu10k1_card *card, struct emu_timer *timer)
{
	unsigned long flags;
 
	spin_lock_irqsave(&card->timer_lock, flags);
	timer->state &= ~TIMER_STATE_ACTIVE;
	spin_unlock_irqrestore(&card->timer_lock, flags);
 
	return;
}