kernel/rtctimer.c100644 764 764 15533 6766214256 13127 0ustar stevesteve/* * RTC based timer for ALSA. * * Copyright (C) 1999 Steve Ratcliffe * Borrows heavily from rtc.c which is Copyright (C) 1996 Paul Gortmaker * * 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. * */ /* * This timer uses the RTC chip that is on all PC's. It * is useful for the i386 as HZ is only 100. It is probably not needed * on the Alpha as HZ is 1024. * This is a separate module, if it is loaded then it registers * itself as an available timer. Other modules may then select this * timer for use. */ #define SND_MAIN_OBJECT_FILE #include "../include/driver.h" #include "../include/timer.h" #include #include #define RTC_FREQ 1024 /* Frequency to run periodic interrupts */ #define RTC_IRQ 8 /* The IRQ for the rtc chip periodic interrupts */ #define RTC_IO_EXTENT 0x10 #define NANO_SEC 1000000000 /* Number of nanoseconds in a second */ spinlock_t reg; /* Prototypes for static functions */ static int rtctimer_open(snd_timer_t *t); static int rtctimer_close(snd_timer_t *t); static unsigned long rtctimer_resolution(snd_timer_t *t); static void rtctimer_start(snd_timer_t *t); static void rtctimer_stop(snd_timer_t *t); static void rtctimer_interrupt(int irq, void *dev_id, struct pt_regs *regs); static void unset_rtc_irq_bit(unsigned char bit); static void set_rtc_irq_bit(unsigned char bit); static void reg_timer(void); static void unreg_timer(void); /* * The harware depenant description for this timer. */ static struct snd_stru_timer_hardware rtc_hw = { 0, NANO_SEC/RTC_FREQ, /* Resolution. Use c_resolution() */ 100000000, /* max number of ticks from this timer, really more */ rtctimer_open, /* Open */ rtctimer_close, /* Close */ rtctimer_resolution, /* Returns resolution */ rtctimer_start, /* Start the timer */ rtctimer_stop, /* Stop the timer */ }; /* * This module implements one timer. But there is no reason why it * should not implement more. Each would have its own ticks value and * so could run at a different rate. */ static unsigned int rtctimer_freq = RTC_FREQ; static snd_timer_t *rtctimer; static int rtctimer_open(snd_timer_t *t) { MOD_INC_USE_COUNT; return 0; } static int rtctimer_close(snd_timer_t *t) { MOD_DEC_USE_COUNT; return 0; } /* * Returns resolution in nsec. */ static unsigned long rtctimer_resolution(snd_timer_t *t) { return NANO_SEC/rtctimer_freq; } /* * Start the timer. This enables periodic interrupts at the selected * frequency. * NOTE: If ticks is more than 1, then it is kind of pointless running * at a high frequency. We could divide it down. */ static void rtctimer_start(snd_timer_t *t) { unsigned long flags; unsigned int val; int power2; /* * Note that we could use ticks to divide down the clock frequency: * at present we callback after every t->ticks interrupts which * is kind of pointless... XXX */ /* Get the power of two that represents rtctimer_freq */ power2 = 0; while (rtctimer_freq > (1 << power2)) power2++; if (power2 > 16) power2 = 16; /* Set the update frequency */ spin_lock_irqsave(®, flags); val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0; val |= (16 - power2); CMOS_WRITE(val, RTC_FREQ_SELECT); spin_unlock_irqrestore(®, flags); /* Turn on periodic interrupts */ set_rtc_irq_bit(RTC_PIE); } /* * Turn off periodic interrupts. */ static void rtctimer_stop(snd_timer_t *t) { /* Turn off periodic interrupts */ unset_rtc_irq_bit(RTC_PIE); } /* * A very tiny interrupt handler. It runs with SA_INTERRUPT set, * so that there is no possibility of conflicting with the * set_rtc_mmss() call that happens during some timer interrupts. * (See ./arch/XXXX/kernel/time.c for the set_rtc_mmss() function.) */ static void rtctimer_interrupt(int irq, void *dev_id, struct pt_regs *regs) { snd_timer_t *t; t = rtctimer; if (t == NULL) return; snd_timer_interrupt(t, t->sticks); /* Re-enable interrupts by reading the flags register */ CMOS_READ(RTC_INTR_FLAGS); #if 0 /* The next bit is a crowbar function in case an interrupt is * missed and the timer stops */ if (t->flags & SND_TIMER_FLG_RUNNING) mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100); #endif } /* * Used to disable/enable interrupts for any one of UIE, AIE, PIE. * Rumour has it that if you frob the interrupt enable/disable * bits in RTC_CONTROL, you should read RTC_INTR_FLAGS, to * ensure you actually start getting interrupts. Probably for * compatibility with older/broken chipset RTC implementations. * We also clear out any old irq data after an ioctl() that * meddles with the interrupt enable/disable bits. */ static void unset_rtc_irq_bit(unsigned char bit) { unsigned char val; unsigned long flags; spin_lock_irqsave(®, flags); val = CMOS_READ(RTC_CONTROL); val &= ~bit; CMOS_WRITE(val, RTC_CONTROL); CMOS_READ(RTC_INTR_FLAGS); spin_unlock_irqrestore(®, flags); } static void set_rtc_irq_bit(unsigned char bit) { unsigned char val; unsigned long flags; spin_lock_irqsave(®, flags); val = CMOS_READ(RTC_CONTROL); val |= bit; CMOS_WRITE(val, RTC_CONTROL); CMOS_READ(RTC_INTR_FLAGS); spin_unlock_irqrestore(®, flags); } /* * Register the timer with alsa. Only run at module load time * so I assume is not multithreaded. */ static void reg_timer(void) { snd_timer_t *t; /* Create a new timer and set up the fields */ t = snd_timer_new_device(NULL, "rtc"); strncpy(t->name, "RTC hi-res timer", sizeof(t->name)-1); t->private_data = NULL; memcpy(&t->hw, &rtc_hw, sizeof(rtc_hw)); /* Actually register */ #define DEVICE_NUMBER 1 /* ??? */ if (snd_timer_register(t, DEVICE_NUMBER) < 0) { snd_timer_free(t); t = NULL; } rtctimer = t; } /* * Unregister the timer from ALSA. */ static void unreg_timer(void) { if (rtctimer) { snd_timer_unregister(rtctimer); rtctimer = NULL; } } /* * ENTRY functions */ int init_module(void) { snd_printk("Hi-resolution timer module\n"); if (request_irq(RTC_IRQ, rtctimer_interrupt, SA_INTERRUPT, "RTCtimer", 0)) { snd_printk("rtc timer: IRQ %d is not free\n", RTC_IRQ); return -ENXIO; } request_region(RTC_PORT(0), RTC_IO_EXTENT, "rtctimer"); reg_timer(); return 0; } void cleanup_module(void) { unreg_timer(); release_region(RTC_PORT(0), RTC_IO_EXTENT); free_irq(RTC_IRQ, 0); } kernel/Makefile.timer100664 764 764 1327 6664256303 13663 0ustar stevesteve# # Makefile for ALSA low level driver (Linux version) # Copyright (c) 1994-98 by Jaroslav Kysela # TOPDIR = .. include $(TOPDIR)/Makefile.conf TARGETS = $(SNDVERSIONS) \ snd-rtctimer.o RTCTIMER = rtctimer.o include $(TOPDIR)/Rules.make all: $(TARGETS) @echo @echo "ALSA hi-resolution timer was sucessfully compiled." @echo include $(TOPDIR)/Rules1.make snd-rtctimer.o: .depend $(SNDVERSIONS) $(RTCTIMER) $(LINKER) -o $@ $(RTCTIMER); gcompile: $(TARGETS) clean: rm -f snd-rtctimer.o *rtc*.o rm -f core .depend: $(SYMFILES) $(CPP) $(COPTS) $(INCLUDE) *.c > .depend dep: .depend dummy: # # include a dependency file if one exists # ifeq (.depend,$(wildcard .depend)) include .depend endif