1 2/* 3 ********************************************************************** 4 * timer.c 5 * Copyright (C) 1999, 2000 Creative Labs, inc. 6 * 7 ********************************************************************** 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation; either version 2 of 12 * the License, or (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public 20 * License along with this program; if not, write to the Free 21 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, 22 * USA. 23 * 24 ********************************************************************** 25 */ 26 27/* 3/6/2000 Improved support for different timer delays Rui Sousa */ 28 29/* 4/3/2000 Implemented timer list using list.h Rui Sousa */ 30 31#include "hwaccess.h" 32#include "8010.h" 33#include "irqmgr.h" 34#include "timer.h" 35 36/* Try to schedule only once per fragment */ 37 38void emu10k1_timer_irqhandler(struct emu10k1_card *card) 39{ 40 struct emu_timer *t; 41 struct list_head *entry; 42 43 spin_lock(&card->timer_lock); 44 45 list_for_each(entry, &card->timers) { 46 t = list_entry(entry, struct emu_timer, list); 47 48 if (t->state & TIMER_STATE_ACTIVE) { 49 t->count++; 50 if (t->count == t->count_max) { 51 t->count = 0; 52 tasklet_hi_schedule(&t->tasklet); 53 } 54 } 55 } 56 57 spin_unlock(&card->timer_lock); 58 59 return; 60} 61 62void emu10k1_timer_install(struct emu10k1_card *card, struct emu_timer *timer, u16 delay) 63{ 64 struct emu_timer *t; 65 struct list_head *entry; 66 unsigned long flags; 67 68 if (delay < 5) 69 delay = 5; 70 71 timer->delay = delay; 72 timer->state = TIMER_STATE_INSTALLED; 73 74 spin_lock_irqsave(&card->timer_lock, flags); 75 76 timer->count_max = timer->delay / (card->timer_delay < 1024 ? card->timer_delay : 1024); 77 timer->count = timer->count_max - 1; 78 79 list_add(&timer->list, &card->timers); 80 81 if (card->timer_delay > delay) { 82 if (card->timer_delay == TIMER_STOPPED) 83 emu10k1_irq_enable(card, INTE_INTERVALTIMERENB); 84 85 card->timer_delay = delay; 86 delay = (delay < 1024 ? delay : 1024); 87 88 emu10k1_timer_set(card, delay); 89 90 list_for_each(entry, &card->timers) { 91 t = list_entry(entry, struct emu_timer, list); 92 93 t->count_max = t->delay / delay; 94 /* don't want to think much, just force scheduling 95 on the next interrupt */ 96 t->count = t->count_max - 1; 97 } 98 99 DPD(2, "timer rate --> %u\n", delay); 100 } 101 102 spin_unlock_irqrestore(&card->timer_lock, flags); 103 104 return; 105} 106 107void emu10k1_timer_uninstall(struct emu10k1_card *card, struct emu_timer *timer) 108{ 109 struct emu_timer *t; 110 struct list_head *entry; 111 u16 delay = TIMER_STOPPED; 112 unsigned long flags; 113 114 if (timer->state == TIMER_STATE_UNINSTALLED) 115 return; 116 117 spin_lock_irqsave(&card->timer_lock, flags); 118 119 list_del(&timer->list); 120 121 list_for_each(entry, &card->timers) { 122 t = list_entry(entry, struct emu_timer, list); 123 124 if (t->delay < delay) 125 delay = t->delay; 126 } 127 128 if (card->timer_delay != delay) { 129 card->timer_delay = delay; 130 131 if (delay == TIMER_STOPPED) 132 emu10k1_irq_disable(card, INTE_INTERVALTIMERENB); 133 else { 134 delay = (delay < 1024 ? delay : 1024); 135 136 emu10k1_timer_set(card, delay); 137 138 list_for_each(entry, &card->timers) { 139 t = list_entry(entry, struct emu_timer, list); 140 141 t->count_max = t->delay / delay; 142 t->count = t->count_max - 1; 143 } 144 } 145 146 DPD(2, "timer rate --> %u\n", delay); 147 } 148 149 spin_unlock_irqrestore(&card->timer_lock, flags); 150 151 timer->state = TIMER_STATE_UNINSTALLED; 152 153 return; 154} 155 156void emu10k1_timer_enable(struct emu10k1_card *card, struct emu_timer *timer) 157{ 158 unsigned long flags; 159 160 spin_lock_irqsave(&card->timer_lock, flags); 161 timer->state |= TIMER_STATE_ACTIVE; 162 spin_unlock_irqrestore(&card->timer_lock, flags); 163 164 return; 165} 166 167void emu10k1_timer_disable(struct emu10k1_card *card, struct emu_timer *timer) 168{ 169 unsigned long flags; 170 171 spin_lock_irqsave(&card->timer_lock, flags); 172 timer->state &= ~TIMER_STATE_ACTIVE; 173 spin_unlock_irqrestore(&card->timer_lock, flags); 174 175 return; 176} 177