/* * Timer device implementation for SGI SN platforms. * * This file is subject to the terms and conditions of the GNU General Public * License.  See the file "COPYING" in the main directory of this archive * for more details. * * Copyright (c) 2001-2006 Silicon Graphics, Inc.  All rights reserved. * * This driver exports an API that should be supportable by any HPET or IA-PC * multimedia timer.  The code below is currently specific to the SGI Altix * SHub RTC, however. * * 11/01/01 - jbarnes - initial revision * 9/10/04 - Christoph Lameter - remove interrupt support for kernel inclusion * 10/1/04 - Christoph Lameter - provide posix clock CLOCK_SGI_CYCLE * 10/13/04 - Christoph Lameter, Dimitri Sivanich - provide timer interrupt *		support via the posix timer interface */ #include <linux/types.h>#include <linux/kernel.h>#include <linux/ioctl.h>#include <linux/module.h>#include <linux/init.h>#include <linux/errno.h>#include <linux/mm.h>#include <linux/fs.h>#include <linux/mmtimer.h>#include <linux/miscdevice.h>#include <linux/posix-timers.h>#include <linux/interrupt.h>#include <linux/time.h>#include <linux/math64.h>#include <linux/mutex.h>#include <linux/slab.h> #include <asm/uaccess.h>#include <asm/sn/addrs.h>#include <asm/sn/intr.h>#include <asm/sn/shub_mmr.h>#include <asm/sn/nodepda.h>#include <asm/sn/shubio.h> MODULE_AUTHOR("Jesse Barnes <jbarnes@sgi.com>");MODULE_DESCRIPTION("SGI Altix RTC Timer");MODULE_LICENSE("GPL"); /* name of the device, usually in /dev */#define MMTIMER_NAME "mmtimer"#define MMTIMER_DESC "SGI Altix RTC Timer"#define MMTIMER_VERSION "2.1" #define RTC_BITS 55 /* 55 bits for this implementation */ static struct k_clock sgi_clock; extern unsigned long sn_rtc_cycles_per_second; #define RTC_COUNTER_ADDR        ((long *)LOCAL_MMR_ADDR(SH_RTC)) #define rtc_time()              (*RTC_COUNTER_ADDR) static DEFINE_MUTEX(mmtimer_mutex);static long mmtimer_ioctl(struct file *file, unsigned int cmd,						unsigned long arg);static int mmtimer_mmap(struct file *file, struct vm_area_struct *vma); /* * Period in femtoseconds (10^-15 s) */static unsigned long mmtimer_femtoperiod = 0; static const struct file_operations mmtimer_fops = {	.owner = THIS_MODULE,	.mmap =	mmtimer_mmap,	.unlocked_ioctl = mmtimer_ioctl,	.llseek = noop_llseek,}; /* * We only have comparison registers RTC1-4 currently available per * node.  RTC0 is used by SAL. *//* Check for an RTC interrupt pending */static int mmtimer_int_pending(int comparator){	if (HUB_L((unsigned long *)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED)) &			SH_EVENT_OCCURRED_RTC1_INT_MASK << comparator)		return 1;	else		return 0;} /* Clear the RTC interrupt pending bit */static void mmtimer_clr_int_pending(int comparator){	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED_ALIAS),		SH_EVENT_OCCURRED_RTC1_INT_MASK << comparator);} /* Setup timer on comparator RTC1 */static void mmtimer_setup_int_0(int cpu, u64 expires){	u64 val; 	/* Disable interrupt */	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC1_INT_ENABLE), 0UL); 	/* Initialize comparator value */	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_INT_CMPB), -1L); 	/* Clear pending bit */	mmtimer_clr_int_pending(0); 	val = ((u64)SGI_MMTIMER_VECTOR << SH_RTC1_INT_CONFIG_IDX_SHFT) |		((u64)cpu_physical_id(cpu) <<			SH_RTC1_INT_CONFIG_PID_SHFT); 	/* Set configuration */	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC1_INT_CONFIG), val); 	/* Enable RTC interrupts */	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC1_INT_ENABLE), 1UL); 	/* Initialize comparator value */	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_INT_CMPB), expires);  } /* Setup timer on comparator RTC2 */static void mmtimer_setup_int_1(int cpu, u64 expires){	u64 val; 	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC2_INT_ENABLE), 0UL); 	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_INT_CMPC), -1L); 	mmtimer_clr_int_pending(1); 	val = ((u64)SGI_MMTIMER_VECTOR << SH_RTC2_INT_CONFIG_IDX_SHFT) |		((u64)cpu_physical_id(cpu) <<			SH_RTC2_INT_CONFIG_PID_SHFT); 	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC2_INT_CONFIG), val); 	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC2_INT_ENABLE), 1UL); 	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_INT_CMPC), expires);} /* Setup timer on comparator RTC3 */static void mmtimer_setup_int_2(int cpu, u64 expires){	u64 val; 	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC3_INT_ENABLE), 0UL); 	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_INT_CMPD), -1L); 	mmtimer_clr_int_pending(2); 	val = ((u64)SGI_MMTIMER_VECTOR << SH_RTC3_INT_CONFIG_IDX_SHFT) |		((u64)cpu_physical_id(cpu) <<			SH_RTC3_INT_CONFIG_PID_SHFT); 	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC3_INT_CONFIG), val); 	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC3_INT_ENABLE), 1UL); 	HUB_S((u64 *)LOCAL_MMR_ADDR(SH_INT_CMPD), expires);} /* * This function must be called with interrupts disabled and preemption off * in order to insure that the setup succeeds in a deterministic time frame. * It will check if the interrupt setup succeeded. */static int mmtimer_setup(int cpu, int comparator, unsigned long expires,	u64 *set_completion_time){	switch (comparator) {	case 0:		mmtimer_setup_int_0(cpu, expires);		break;	case 1:		mmtimer_setup_int_1(cpu, expires);		break;	case 2:		mmtimer_setup_int_2(cpu, expires);		break;	}	/* We might've missed our expiration time */	*set_completion_time = rtc_time();	if (*set_completion_time <= expires)		return 1; 	/*	 * If an interrupt is already pending then its okay	 * if not then we failed	 */	return mmtimer_int_pending(comparator);} static int mmtimer_disable_int(long nasid, int comparator){	switch (comparator) {	case 0:		nasid == -1 ? HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC1_INT_ENABLE),			0UL) : REMOTE_HUB_S(nasid, SH_RTC1_INT_ENABLE, 0UL);		break;	case 1:		nasid == -1 ? HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC2_INT_ENABLE),			0UL) : REMOTE_HUB_S(nasid, SH_RTC2_INT_ENABLE, 0UL);		break;	case 2:		nasid == -1 ? HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC3_INT_ENABLE),			0UL) : REMOTE_HUB_S(nasid, SH_RTC3_INT_ENABLE, 0UL);		break;	default:		return -EFAULT;	}	return 0;} #define COMPARATOR	1		/* The comparator to use */ #define TIMER_OFF	0xbadcabLL	/* Timer is not setup */#define TIMER_SET	0		/* Comparator is set for this timer */ #define MMTIMER_INTERVAL_RETRY_INCREMENT_DEFAULT 40 /* There is one of these for each timer */struct mmtimer {	struct rb_node list;	struct k_itimer *timer;	int cpu;}; struct mmtimer_node {	spinlock_t lock ____cacheline_aligned;	struct rb_root timer_head;	struct rb_node *next;	struct tasklet_struct tasklet;};static struct mmtimer_node *timers; static unsigned mmtimer_interval_retry_increment =	MMTIMER_INTERVAL_RETRY_INCREMENT_DEFAULT;module_param(mmtimer_interval_retry_increment, uint, 0644);MODULE_PARM_DESC(mmtimer_interval_retry_increment,	"RTC ticks to add to expiration on interval retry (default 40)"); /* * Add a new mmtimer struct to the node's mmtimer list. * This function assumes the struct mmtimer_node is locked. */static void mmtimer_add_list(struct mmtimer *n){	int nodeid = n->timer->it.mmtimer.node;	unsigned long expires = n->timer->it.mmtimer.expires;	struct rb_node **link = &timers[nodeid].timer_head.rb_node;	struct rb_node *parent = NULL;	struct mmtimer *x; 	/*	 * Find the right place in the rbtree:	 */	while (*link) {		parent = *link;		x = rb_entry(parent, struct mmtimer, list); 		if (expires < x->timer->it.mmtimer.expires)			link = &(*link)->rb_left;		else			link = &(*link)->rb_right;	} 	/*	 * Insert the timer to the rbtree and check whether it	 * replaces the first pending timer	 */	rb_link_node(&n->list, parent, link);	rb_insert_color(&n->list, &timers[nodeid].timer_head); 	if (!timers[nodeid].next || expires < rb_entry(timers[nodeid].next,			struct mmtimer, list)->timer->it.mmtimer.expires)		timers[nodeid].next = &n->list;} /* * Set the comparator for the next timer. * This function assumes the struct mmtimer_node is locked. */static void mmtimer_set_next_timer(int nodeid){	struct mmtimer_node *n = &timers[nodeid];	struct mmtimer *x;	struct k_itimer *t;	u64 expires, exp, set_completion_time;	int i; restart:	if (n->next == NULL)		return; 	x = rb_entry(n->next, struct mmtimer, list);	t = x->timer;	if (!t->it.mmtimer.incr) {		/* Not an interval timer */		if (!mmtimer_setup(x->cpu, COMPARATOR,					t->it.mmtimer.expires,					&set_completion_time)) {			/* Late setup, fire now */			tasklet_schedule(&n->tasklet);		}		return;	} 	/* Interval timer */	i = 0;	expires = exp = t->it.mmtimer.expires;	while (!mmtimer_setup(x->cpu, COMPARATOR, expires,				&set_completion_time)) {		int to; 		i++;		expires = set_completion_time +				mmtimer_interval_retry_increment + (1 << i);		/* Calculate overruns as we go. */		to = ((u64)(expires - exp) / t->it.mmtimer.incr);		if (to) {			t->it_overrun += to;			t->it.mmtimer.expires += t->it.mmtimer.incr * to;			exp = t->it.mmtimer.expires;		}		if (i > 20) {			printk(KERN_ALERT "mmtimer: cannot reschedule timer\n");			t->it.mmtimer.clock = TIMER_OFF;			n->next = rb_next(&x->list);			rb_erase(&x->list, &n->timer_head);			kfree(x);			goto restart;		}	}} /** * mmtimer_ioctl - ioctl interface for /dev/mmtimer * @file: file structure for the device * @cmd: command to execute * @arg: optional argument to command * * Executes the command specified by @cmd.  Returns 0 for success, < 0 for * failure. * * Valid commands: * * %MMTIMER_GETOFFSET - Should return the offset (relative to the start * of the page where the registers are mapped) for the counter in question. * * %MMTIMER_GETRES - Returns the resolution of the clock in femto (10^-15) * seconds * * %MMTIMER_GETFREQ - Copies the frequency of the clock in Hz to the address * specified by @arg * * %MMTIMER_GETBITS - Returns the number of bits in the clock's counter * * %MMTIMER_MMAPAVAIL - Returns 1 if the registers can be mmap'd into userspace * * %MMTIMER_GETCOUNTER - Gets the current value in the counter and places it * in the address specified by @arg. */static long mmtimer_ioctl(struct file *file, unsigned int cmd,						unsigned long arg){	int ret = 0; 	mutex_lock(&mmtimer_mutex); 	switch (cmd) {	case MMTIMER_GETOFFSET:	/* offset of the counter */		/*		 * SN RTC registers are on their own 64k page		 */		if(PAGE_SIZE <= (1 << 16))			ret = (((long)RTC_COUNTER_ADDR) & (PAGE_SIZE-1)) / 8;		else			ret = -ENOSYS;		break; 	case MMTIMER_GETRES: /* resolution of the clock in 10^-15 s */		if(copy_to_user((unsigned long __user *)arg,				&mmtimer_femtoperiod, sizeof(unsigned long)))			ret = -EFAULT;		break; 	case MMTIMER_GETFREQ: /* frequency in Hz */		if(copy_to_user((unsigned long __user *)arg,				&sn_rtc_cycles_per_second,				sizeof(unsigned long)))			ret = -EFAULT;		break; 	case MMTIMER_GETBITS: /* number of bits in the clock */		ret = RTC_BITS;		break; 	case MMTIMER_MMAPAVAIL: /* can we mmap the clock into userspace? */		ret = (PAGE_SIZE <= (1 << 16)) ? 1 : 0;		break; 	case MMTIMER_GETCOUNTER:		if(copy_to_user((unsigned long __user *)arg,				RTC_COUNTER_ADDR, sizeof(unsigned long)))			ret = -EFAULT;		break;	default:		ret = -ENOTTY;		break;	}	mutex_unlock(&mmtimer_mutex);	return ret;} /** * mmtimer_mmap - maps the clock's registers into userspace * @file: file structure for the device * @vma: VMA to map the registers into * * Calls remap_pfn_range() to map the clock's registers into * the calling process' address space. */static int mmtimer_mmap(struct file *file, struct vm_area_struct *vma){	unsigned long mmtimer_addr; 	if (vma->vm_end - vma->vm_start != PAGE_SIZE)		return -EINVAL; 	if (vma->vm_flags & VM_WRITE)		return -EPERM; 	if (PAGE_SIZE > (1 << 16))		return -ENOSYS; 	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 	mmtimer_addr = __pa(RTC_COUNTER_ADDR);	mmtimer_addr &= ~(PAGE_SIZE - 1);	mmtimer_addr &= 0xfffffffffffffffUL; 	if (remap_pfn_range(vma, vma->vm_start, mmtimer_addr >> PAGE_SHIFT,					PAGE_SIZE, vma->vm_page_prot)) {		printk(KERN_ERR "remap_pfn_range failed in mmtimer.c\n");		return -EAGAIN;	} 	return 0;} static struct miscdevice mmtimer_miscdev = {	SGI_MMTIMER,	MMTIMER_NAME,	&mmtimer_fops}; static struct timespec sgi_clock_offset;static int sgi_clock_period; /* * Posix Timer Interface */ static struct timespec sgi_clock_offset;static int sgi_clock_period; static int sgi_clock_get(clockid_t clockid, struct timespec *tp){	u64 nsec; 	nsec = rtc_time() * sgi_clock_period			+ sgi_clock_offset.tv_nsec;	*tp = ns_to_timespec(nsec);	tp->tv_sec += sgi_clock_offset.tv_sec;	return 0;}; static int sgi_clock_set(const clockid_t clockid, const struct timespec *tp){ 	u64 nsec;	u32 rem; 	nsec = rtc_time() * sgi_clock_period; 	sgi_clock_offset.tv_sec = tp->tv_sec - div_u64_rem(nsec, NSEC_PER_SEC, &rem);

Lines 1–500 of 859. Load more