Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 176 insertions, 0 deletions

diff --git a/sound/oss/emu10k1/timer.c b/sound/oss/emu10k1/timer.c
new file mode 100644
index 000000000000..d10d30739f41
--- /dev/null
+++ b/sound/oss/emu10k1/timer.c
@@ -0,0 +1,176 @@
+
+/*
+ **********************************************************************
+ *     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;
+}