[deliverable/linux.git] / drivers / isdn / mISDN / clock.c

/*
 * Copyright 2008  by Andreas Eversberg <andreas@eversberg.eu>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * 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.
 *
 * Quick API description:
 *
 * A clock source registers using mISDN_register_clock:
 *	name = text string to name clock source
 *	priority = value to priorize clock sources (0 = default)
 *	ctl = callback function to enable/disable clock source
 *	priv = private pointer of clock source
 *	return = pointer to clock source structure;
 *
 * Note: Callback 'ctl' can be called before mISDN_register_clock returns!
 *       Also it can be called during mISDN_unregister_clock.
 *
 * A clock source calls mISDN_clock_update with given samples elapsed, if
 * enabled. If function call is delayed, tv must be set with the timestamp
 * of the actual event.
 *
 * A clock source unregisters using mISDN_unregister_clock.
 *
 * To get current clock, call mISDN_clock_get. The signed short value
 * counts the number of samples since. Time since last clock event is added.
 *
 */

#include <linux/slab.h>
#include <linux/types.h>
#include <linux/stddef.h>
#include <linux/spinlock.h>
#include <linux/mISDNif.h>
#include <linux/export.h>
#include "core.h"

static u_int *debug;
static LIST_HEAD(iclock_list);
static DEFINE_RWLOCK(iclock_lock);
static u16 iclock_count;		/* counter of last clock */
static struct timeval iclock_tv;	/* time stamp of last clock */
static int iclock_tv_valid;		/* already received one timestamp */
static struct mISDNclock *iclock_current;

void
mISDN_init_clock(u_int *dp)
{
	debug = dp;
	do_gettimeofday(&iclock_tv);
}

static void
select_iclock(void)
{
	struct mISDNclock *iclock, *bestclock = NULL, *lastclock = NULL;
	int pri = -128;

	list_for_each_entry(iclock, &iclock_list, list) {
		if (iclock->pri > pri) {
			pri = iclock->pri;
			bestclock = iclock;
		}
		if (iclock_current == iclock)
			lastclock = iclock;
	}
	if (lastclock && bestclock != lastclock) {
		/* last used clock source still exists but changes, disable */
		if (*debug & DEBUG_CLOCK)
			printk(KERN_DEBUG "Old clock source '%s' disable.\n",
			       lastclock->name);
		lastclock->ctl(lastclock->priv, 0);
	}
	if (bestclock && bestclock != iclock_current) {
		/* new clock source selected, enable */
		if (*debug & DEBUG_CLOCK)
			printk(KERN_DEBUG "New clock source '%s' enable.\n",
			       bestclock->name);
		bestclock->ctl(bestclock->priv, 1);
	}
	if (bestclock != iclock_current) {
		/* no clock received yet */
		iclock_tv_valid = 0;
	}
	iclock_current = bestclock;
}

struct mISDNclock
*mISDN_register_clock(char *name, int pri, clockctl_func_t *ctl, void *priv)
{
	u_long			flags;
	struct mISDNclock	*iclock;

	if (*debug & (DEBUG_CORE | DEBUG_CLOCK))
		printk(KERN_DEBUG "%s: %s %d\n", __func__, name, pri);
	iclock = kzalloc(sizeof(struct mISDNclock), GFP_ATOMIC);
	if (!iclock) {
		printk(KERN_ERR "%s: No memory for clock entry.\n", __func__);
		return NULL;
	}
	strncpy(iclock->name, name, sizeof(iclock->name) - 1);
	iclock->pri = pri;
	iclock->priv = priv;
	iclock->ctl = ctl;
	write_lock_irqsave(&iclock_lock, flags);
	list_add_tail(&iclock->list, &iclock_list);
	select_iclock();
	write_unlock_irqrestore(&iclock_lock, flags);
	return iclock;
}
EXPORT_SYMBOL(mISDN_register_clock);

void
mISDN_unregister_clock(struct mISDNclock *iclock)
{
	u_long	flags;

	if (*debug & (DEBUG_CORE | DEBUG_CLOCK))
		printk(KERN_DEBUG "%s: %s %d\n", __func__, iclock->name,
		       iclock->pri);
	write_lock_irqsave(&iclock_lock, flags);
	if (iclock_current == iclock) {
		if (*debug & DEBUG_CLOCK)
			printk(KERN_DEBUG
			       "Current clock source '%s' unregisters.\n",
			       iclock->name);
		iclock->ctl(iclock->priv, 0);
	}
	list_del(&iclock->list);
	select_iclock();
	write_unlock_irqrestore(&iclock_lock, flags);
}
EXPORT_SYMBOL(mISDN_unregister_clock);

void
mISDN_clock_update(struct mISDNclock *iclock, int samples, struct timeval *tv)
{
	u_long		flags;
	struct timeval	tv_now;
	time_t		elapsed_sec;
	int		elapsed_8000th;

	write_lock_irqsave(&iclock_lock, flags);
	if (iclock_current != iclock) {
		printk(KERN_ERR "%s: '%s' sends us clock updates, but we do "
		       "listen to '%s'. This is a bug!\n", __func__,
		       iclock->name,
		       iclock_current ? iclock_current->name : "nothing");
		iclock->ctl(iclock->priv, 0);
		write_unlock_irqrestore(&iclock_lock, flags);
		return;
	}
	if (iclock_tv_valid) {
		/* increment sample counter by given samples */
		iclock_count += samples;
		if (tv) { /* tv must be set, if function call is delayed */
			iclock_tv.tv_sec = tv->tv_sec;
			iclock_tv.tv_usec = tv->tv_usec;
		} else
			do_gettimeofday(&iclock_tv);
	} else {
		/* calc elapsed time by system clock */
		if (tv) { /* tv must be set, if function call is delayed */
			tv_now.tv_sec = tv->tv_sec;
			tv_now.tv_usec = tv->tv_usec;
		} else
			do_gettimeofday(&tv_now);
		elapsed_sec = tv_now.tv_sec - iclock_tv.tv_sec;
		elapsed_8000th = (tv_now.tv_usec / 125)
			- (iclock_tv.tv_usec / 125);
		if (elapsed_8000th < 0) {
			elapsed_sec -= 1;
			elapsed_8000th += 8000;
		}
		/* add elapsed time to counter and set new timestamp */
		iclock_count += elapsed_sec * 8000 + elapsed_8000th;
		iclock_tv.tv_sec = tv_now.tv_sec;
		iclock_tv.tv_usec = tv_now.tv_usec;
		iclock_tv_valid = 1;
		if (*debug & DEBUG_CLOCK)
			printk("Received first clock from source '%s'.\n",
			       iclock_current ? iclock_current->name : "nothing");
	}
	write_unlock_irqrestore(&iclock_lock, flags);
}
EXPORT_SYMBOL(mISDN_clock_update);

unsigned short
mISDN_clock_get(void)
{
	u_long		flags;
	struct timeval	tv_now;
	time_t		elapsed_sec;
	int		elapsed_8000th;
	u16		count;

	read_lock_irqsave(&iclock_lock, flags);
	/* calc elapsed time by system clock */
	do_gettimeofday(&tv_now);
	elapsed_sec = tv_now.tv_sec - iclock_tv.tv_sec;
	elapsed_8000th = (tv_now.tv_usec / 125) - (iclock_tv.tv_usec / 125);
	if (elapsed_8000th < 0) {
		elapsed_sec -= 1;
		elapsed_8000th += 8000;
	}
	/* add elapsed time to counter */
	count =	iclock_count + elapsed_sec * 8000 + elapsed_8000th;
	read_unlock_irqrestore(&iclock_lock, flags);
	return count;
}
EXPORT_SYMBOL(mISDN_clock_get);
Commit	Line	Data
3bd69ad1 AE	1	/*
	2	* Copyright 2008 by Andreas Eversberg <andreas@eversberg.eu>
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2 as
	6	* published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	* Quick API description:
	14	*
	15	* A clock source registers using mISDN_register_clock:
475be4d8	16	* name = text string to name clock source
3bd69ad1 AE	17	* priority = value to priorize clock sources (0 = default)
	18	* ctl = callback function to enable/disable clock source
	19	* priv = private pointer of clock source
475be4d8	20	* return = pointer to clock source structure;
3bd69ad1 AE	21	*
	22	* Note: Callback 'ctl' can be called before mISDN_register_clock returns!
	23	* Also it can be called during mISDN_unregister_clock.
	24	*
	25	* A clock source calls mISDN_clock_update with given samples elapsed, if
	26	* enabled. If function call is delayed, tv must be set with the timestamp
	27	* of the actual event.
	28	*
	29	* A clock source unregisters using mISDN_unregister_clock.
	30	*
	31	* To get current clock, call mISDN_clock_get. The signed short value
	32	* counts the number of samples since. Time since last clock event is added.
	33	*
	34	*/
	35
5a0e3ad6	36	#include <linux/slab.h>
3bd69ad1 AE	37	#include <linux/types.h>
	38	#include <linux/stddef.h>
	39	#include <linux/spinlock.h>
	40	#include <linux/mISDNif.h>
5d76fc21	41	#include <linux/export.h>
3bd69ad1 AE	42	#include "core.h"
	43
	44	static u_int *debug;
	45	static LIST_HEAD(iclock_list);
f8532fde HE	46	static DEFINE_RWLOCK(iclock_lock);
	47	static u16 iclock_count; /* counter of last clock */
	48	static struct timeval iclock_tv; /* time stamp of last clock */
	49	static int iclock_tv_valid; /* already received one timestamp */
	50	static struct mISDNclock *iclock_current;
3bd69ad1 AE	51
	52	void
	53	mISDN_init_clock(u_int *dp)
	54	{
	55	debug = dp;
	56	do_gettimeofday(&iclock_tv);
	57	}
	58
	59	static void
	60	select_iclock(void)
	61	{
	62	struct mISDNclock iclock, bestclock = NULL, *lastclock = NULL;
	63	int pri = -128;
	64
	65	list_for_each_entry(iclock, &iclock_list, list) {
	66	if (iclock->pri > pri) {
	67	pri = iclock->pri;
	68	bestclock = iclock;
	69	}
	70	if (iclock_current == iclock)
	71	lastclock = iclock;
	72	}
	73	if (lastclock && bestclock != lastclock) {
	74	/* last used clock source still exists but changes, disable */
	75	if (*debug & DEBUG_CLOCK)
	76	printk(KERN_DEBUG "Old clock source '%s' disable.\n",
475be4d8	77	lastclock->name);
3bd69ad1 AE	78	lastclock->ctl(lastclock->priv, 0);
	79	}
	80	if (bestclock && bestclock != iclock_current) {
	81	/* new clock source selected, enable */
	82	if (*debug & DEBUG_CLOCK)
	83	printk(KERN_DEBUG "New clock source '%s' enable.\n",
475be4d8	84	bestclock->name);
3bd69ad1 AE	85	bestclock->ctl(bestclock->priv, 1);
	86	}
	87	if (bestclock != iclock_current) {
	88	/* no clock received yet */
	89	iclock_tv_valid = 0;
	90	}
	91	iclock_current = bestclock;
	92	}
	93
	94	struct mISDNclock
	95	mISDN_register_clock(char name, int pri, clockctl_func_t ctl, void priv)
	96	{
	97	u_long flags;
	98	struct mISDNclock *iclock;
	99
	100	if (*debug & (DEBUG_CORE \| DEBUG_CLOCK))
	101	printk(KERN_DEBUG "%s: %s %d\n", __func__, name, pri);
	102	iclock = kzalloc(sizeof(struct mISDNclock), GFP_ATOMIC);
	103	if (!iclock) {
	104	printk(KERN_ERR "%s: No memory for clock entry.\n", __func__);
	105	return NULL;
	106	}
475be4d8	107	strncpy(iclock->name, name, sizeof(iclock->name) - 1);
3bd69ad1 AE	108	iclock->pri = pri;
	109	iclock->priv = priv;
	110	iclock->ctl = ctl;
	111	write_lock_irqsave(&iclock_lock, flags);
	112	list_add_tail(&iclock->list, &iclock_list);
	113	select_iclock();
	114	write_unlock_irqrestore(&iclock_lock, flags);
	115	return iclock;
	116	}
	117	EXPORT_SYMBOL(mISDN_register_clock);
	118
	119	void
	120	mISDN_unregister_clock(struct mISDNclock *iclock)
	121	{
	122	u_long flags;
	123
	124	if (*debug & (DEBUG_CORE \| DEBUG_CLOCK))
	125	printk(KERN_DEBUG "%s: %s %d\n", __func__, iclock->name,
475be4d8	126	iclock->pri);
3bd69ad1 AE	127	write_lock_irqsave(&iclock_lock, flags);
	128	if (iclock_current == iclock) {
	129	if (*debug & DEBUG_CLOCK)
	130	printk(KERN_DEBUG
475be4d8 JP	131	"Current clock source '%s' unregisters.\n",
475be4d8 JP	132	iclock->name);
3bd69ad1 AE	133	iclock->ctl(iclock->priv, 0);
	134	}
	135	list_del(&iclock->list);
	136	select_iclock();
	137	write_unlock_irqrestore(&iclock_lock, flags);
	138	}
	139	EXPORT_SYMBOL(mISDN_unregister_clock);
	140
	141	void
	142	mISDN_clock_update(struct mISDNclock iclock, int samples, struct timeval tv)
	143	{
	144	u_long flags;
	145	struct timeval tv_now;
	146	time_t elapsed_sec;
	147	int elapsed_8000th;
	148
	149	write_lock_irqsave(&iclock_lock, flags);
	150	if (iclock_current != iclock) {
	151	printk(KERN_ERR "%s: '%s' sends us clock updates, but we do "
475be4d8 JP	152	"listen to '%s'. This is a bug!\n", __func__,
	153	iclock->name,
	154	iclock_current ? iclock_current->name : "nothing");
3bd69ad1 AE	155	iclock->ctl(iclock->priv, 0);
	156	write_unlock_irqrestore(&iclock_lock, flags);
	157	return;
	158	}
	159	if (iclock_tv_valid) {
	160	/* increment sample counter by given samples */
	161	iclock_count += samples;
	162	if (tv) { /* tv must be set, if function call is delayed */
	163	iclock_tv.tv_sec = tv->tv_sec;
	164	iclock_tv.tv_usec = tv->tv_usec;
	165	} else
	166	do_gettimeofday(&iclock_tv);
	167	} else {
	168	/* calc elapsed time by system clock */
	169	if (tv) { /* tv must be set, if function call is delayed */
	170	tv_now.tv_sec = tv->tv_sec;
	171	tv_now.tv_usec = tv->tv_usec;
	172	} else
	173	do_gettimeofday(&tv_now);
	174	elapsed_sec = tv_now.tv_sec - iclock_tv.tv_sec;
	175	elapsed_8000th = (tv_now.tv_usec / 125)
	176	- (iclock_tv.tv_usec / 125);
	177	if (elapsed_8000th < 0) {
	178	elapsed_sec -= 1;
	179	elapsed_8000th += 8000;
	180	}
	181	/* add elapsed time to counter and set new timestamp */
	182	iclock_count += elapsed_sec * 8000 + elapsed_8000th;
	183	iclock_tv.tv_sec = tv_now.tv_sec;
	184	iclock_tv.tv_usec = tv_now.tv_usec;
	185	iclock_tv_valid = 1;
	186	if (*debug & DEBUG_CLOCK)
	187	printk("Received first clock from source '%s'.\n",
475be4d8	188	iclock_current ? iclock_current->name : "nothing");
3bd69ad1 AE	189	}
	190	write_unlock_irqrestore(&iclock_lock, flags);
	191	}
	192	EXPORT_SYMBOL(mISDN_clock_update);
	193
	194	unsigned short
	195	mISDN_clock_get(void)
	196	{
	197	u_long flags;
	198	struct timeval tv_now;
	199	time_t elapsed_sec;
	200	int elapsed_8000th;
	201	u16 count;
	202
	203	read_lock_irqsave(&iclock_lock, flags);
	204	/* calc elapsed time by system clock */
	205	do_gettimeofday(&tv_now);
	206	elapsed_sec = tv_now.tv_sec - iclock_tv.tv_sec;
	207	elapsed_8000th = (tv_now.tv_usec / 125) - (iclock_tv.tv_usec / 125);
	208	if (elapsed_8000th < 0) {
	209	elapsed_sec -= 1;
	210	elapsed_8000th += 8000;
	211	}
	212	/* add elapsed time to counter */
	213	count = iclock_count + elapsed_sec * 8000 + elapsed_8000th;
	214	read_unlock_irqrestore(&iclock_lock, flags);
	215	return count;
	216	}
	217	EXPORT_SYMBOL(mISDN_clock_get);