CRIS v32: Update and improve fasttimer.c

/* $Id: fasttimer.c,v 1.11 2005/01/04 11:15:46 starvik Exp $

/*

 * linux/arch/cris/kernel/fasttimer.c

 *

 * Fast timers for ETRAX FS

 * This may be useful in other OS than Linux so use 2 space indentation...

 *

 * $Log: fasttimer.c,v $

 * Revision 1.11  2005/01/04 11:15:46  starvik

 * Don't share timer IRQ.

 *

 * Revision 1.10  2004/12/07 09:19:38  starvik

 * Corrected includes.

 * Use correct interrupt macros.

 *

 * Revision 1.9  2004/05/14 10:18:58  starvik

 * Export fast_timer_list

 *

 * Revision 1.8  2004/05/14 07:58:03  starvik

 * Merge of changes from 2.4

 *

 * Revision 1.7  2003/07/10 12:06:14  starvik

 * Return IRQ_NONE if irq wasn't handled

 *

 * Revision 1.6  2003/07/04 08:27:49  starvik

 * Merge of Linux 2.5.74

 *

 * Revision 1.5  2003/06/05 10:16:22  johana

 * New INTR_VECT macros.

 *

 * Revision 1.4  2003/06/03 08:49:45  johana

 * Fixed typo.

 *

 * Revision 1.3  2003/06/02 12:51:27  johana

 * Now compiles.

 * Commented some include files that probably can be removed.

 *

 * Revision 1.2  2003/06/02 12:09:41  johana

 * Ported to ETRAX FS using the trig interrupt instead of timer1.

 *

 * Revision 1.3  2002/12/12 08:26:32  starvik

 * Don't use C-comments inside CVS comments

 *

 * Revision 1.2  2002/12/11 15:42:02  starvik

 * Extracted v10 (ETRAX 100LX) specific stuff from arch/cris/kernel/

 *

 * Revision 1.1  2002/11/18 07:58:06  starvik

 * Fast timers (from Linux 2.4)

 *

 * Revision 1.5  2002/10/15 06:21:39  starvik

 * Added call to init_waitqueue_head

 *

 * Revision 1.4  2002/05/28 17:47:59  johana

 * Added del_fast_timer()

 *

 * Revision 1.3  2002/05/28 16:16:07  johana

 * Handle empty fast_timer_list

 *

 * Revision 1.2  2002/05/27 15:38:42  johana

 * Made it compile without warnings on Linux 2.4.

 * (includes, wait_queue, PROC_FS and snprintf)

 *

 * Revision 1.1  2002/05/27 15:32:25  johana

 * arch/etrax100/kernel/fasttimer.c v1.8 from the elinux tree.

 *

 * Revision 1.8  2001/11/27 13:50:40  pkj

 * Disable interrupts while stopping the timer and while modifying the

 * list of active timers in timer1_handler() as it may be interrupted

 * by other interrupts (e.g., the serial interrupt) which may add fast

 * timers.

 *

 * Revision 1.7  2001/11/22 11:50:32  pkj

 * * Only store information about the last 16 timers.

 * * proc_fasttimer_read() now uses an allocated buffer, since it

 *   requires more space than just a page even for only writing the

 *   last 16 timers. The buffer is only allocated on request, so

 *   unless /proc/fasttimer is read, it is never allocated.

 * * Renamed fast_timer_started to fast_timers_started to match

 *   fast_timers_added and fast_timers_expired.

 * * Some clean-up.

 *

 * Revision 1.6  2000/12/13 14:02:08  johana

 * Removed volatile for fast_timer_list

 *

 * Revision 1.5  2000/12/13 13:55:35  johana

 * Added DEBUG_LOG, added som cli() and cleanup

 *

 * Revision 1.4  2000/12/05 13:48:50  johana

 * Added range check when writing proc file, modified timer int handling

 *

 * Revision 1.3  2000/11/23 10:10:20  johana

 * More debug/logging possibilities.

 * Moved GET_JIFFIES_USEC() to timex.h and time.c

 *

 * Revision 1.2  2000/11/01 13:41:04  johana

 * Clean up and bugfixes.

 * Created new do_gettimeofday_fast() that gets a timeval struct

 * with time based on jiffies and *R_TIMER0_DATA, uses a table

 * for fast conversion of timer value to microseconds.

 * (Much faster the standard do_gettimeofday() and we don't really

 * want to use the true time - we want the "uptime" so timers don't screw up

 * when we change the time.

 * TODO: Add efficient support for continuous timers as well.

 *

 * Revision 1.1  2000/10/26 15:49:16  johana

 * Added fasttimer, highresolution timers.

 *

 * Copyright (C) 2000,2001 2002, 2003 Axis Communications AB, Lund, Sweden

 * Copyright (C) 2000-2006 Axis Communications AB, Lund, Sweden

 */

#include <linux/errno.h>

#include <linux/version.h>

#include <asm/arch/hwregs/reg_map.h>

#include <asm/arch/hwregs/reg_rdwr.h>

#include <asm/arch/hwregs/timer_defs.h>

#include <hwregs/reg_map.h>

#include <hwregs/reg_rdwr.h>

#include <hwregs/timer_defs.h>

#include <asm/fasttimer.h>

#include <linux/proc_fs.h>

#define DEBUG_LOG_INCLUDED

#define FAST_TIMER_LOG

//#define FAST_TIMER_TEST

/* #define FAST_TIMER_TEST */

#define FAST_TIMER_SANITY_CHECKS

#define D2(x)

#define DP(x)

#define __INLINE__ inline

static int fast_timer_running = 0;

static int fast_timers_added = 0;

static int fast_timers_started = 0;

static int fast_timers_expired = 0;

static int fast_timers_deleted = 0;

static int fast_timer_is_init = 0;

static int fast_timer_ints = 0;

static unsigned int fast_timer_running;

static unsigned int fast_timers_added;

static unsigned int fast_timers_started;

static unsigned int fast_timers_expired;

static unsigned int fast_timers_deleted;

static unsigned int fast_timer_is_init;

static unsigned int fast_timer_ints;

struct fast_timer *fast_timer_list = NULL;

#define DEBUG_LOG_MAX 128

static const char * debug_log_string[DEBUG_LOG_MAX];

static unsigned long debug_log_value[DEBUG_LOG_MAX];

static int debug_log_cnt = 0;

static int debug_log_cnt_wrapped = 0;

static unsigned int debug_log_cnt;

static unsigned int debug_log_cnt_wrapped;

#define DEBUG_LOG(string, value) \

{ \

int timer_div_settings[NUM_TIMER_STATS];

int timer_delay_settings[NUM_TIMER_STATS];

struct work_struct fast_work;

static void

timer_trig_handler(void);

timer_trig_handler(struct work_struct *work);

/* Not true gettimeofday, only checks the jiffies (uptime) + useconds */

void __INLINE__ do_gettimeofday_fast(struct timeval *tv)

{

  unsigned long sec = jiffies;

  unsigned long usec = GET_JIFFIES_USEC();

  usec += (sec % HZ) * (1000000 / HZ);

  sec = sec / HZ;

  if (usec > 1000000)

inline void do_gettimeofday_fast(struct fasttime_t *tv)

{

    usec -= 1000000;

    sec++;

  }

  tv->tv_sec = sec;

  tv->tv_usec = usec;

	tv->tv_jiff = jiffies;

	tv->tv_usec = GET_JIFFIES_USEC();

}

int __INLINE__ timeval_cmp(struct timeval *t0, struct timeval *t1)

{

  if (t0->tv_sec < t1->tv_sec)

inline int fasttime_cmp(struct fasttime_t *t0, struct fasttime_t *t1)

{

	/* Compare jiffies. Takes care of wrapping */

	if (time_before(t0->tv_jiff, t1->tv_jiff))

		return -1;

  }

  else if (t0->tv_sec > t1->tv_sec)

  {

	else if (time_after(t0->tv_jiff, t1->tv_jiff))

		return 1;

  }

	/* Compare us */

	if (t0->tv_usec < t1->tv_usec)

  {

		return -1;

  }

	else if (t0->tv_usec > t1->tv_usec)

  {

		return 1;

  }

	return 0;

}

/* Called with ints off */

void __INLINE__ start_timer_trig(unsigned long delay_us)

inline void start_timer_trig(unsigned long delay_us)

{

  reg_timer_rw_ack_intr ack_intr = { 0 };

  reg_timer_rw_intr_mask intr_mask;

  reg_timer_rw_trig trig;

  reg_timer_rw_trig_cfg trig_cfg = { 0 };

  reg_timer_r_time r_time;

	reg_timer_r_time r_time0;

	reg_timer_r_time r_time1;

	unsigned char trig_wrap;

	unsigned char time_wrap;

  r_time = REG_RD(timer, regi_timer, r_time);

	r_time0 = REG_RD(timer, regi_timer0, r_time);

  D1(printk("start_timer_trig : %d us freq: %i div: %i\n",

            delay_us, freq_index, div));

  /* Clear trig irq */

  intr_mask = REG_RD(timer, regi_timer, rw_intr_mask);

	intr_mask = REG_RD(timer, regi_timer0, rw_intr_mask);

  intr_mask.trig = 0;

  REG_WR(timer, regi_timer, rw_intr_mask, intr_mask);

	REG_WR(timer, regi_timer0, rw_intr_mask, intr_mask);

  /* Set timer values */

	/* Set timer values and check if trigger wraps. */

	/* r_time is 100MHz (10 ns resolution) */

  trig = r_time + delay_us*(1000/10);

	trig_wrap = (trig = r_time0 + delay_us*(1000/10)) < r_time0;

  timer_div_settings[fast_timers_started % NUM_TIMER_STATS] = trig;

  timer_delay_settings[fast_timers_started % NUM_TIMER_STATS] = delay_us;

  /* Ack interrupt */

  ack_intr.trig = 1;

  REG_WR(timer, regi_timer, rw_ack_intr, ack_intr);

	REG_WR(timer, regi_timer0, rw_ack_intr, ack_intr);

  /* Start timer */

  REG_WR(timer, regi_timer, rw_trig, trig);

	REG_WR(timer, regi_timer0, rw_trig, trig);

  trig_cfg.tmr = regk_timer_time;

  REG_WR(timer, regi_timer, rw_trig_cfg, trig_cfg);

	REG_WR(timer, regi_timer0, rw_trig_cfg, trig_cfg);

  /* Check if we have already passed the trig time */

  r_time = REG_RD(timer, regi_timer, r_time);

  if (r_time < trig) {

	r_time1 = REG_RD(timer, regi_timer0, r_time);

	time_wrap = r_time1 < r_time0;

	if ((trig_wrap && !time_wrap) || (r_time1 < trig)) {

    /* No, Enable trig irq */

    intr_mask = REG_RD(timer, regi_timer, rw_intr_mask);

		intr_mask = REG_RD(timer, regi_timer0, rw_intr_mask);

    intr_mask.trig = 1;

    REG_WR(timer, regi_timer, rw_intr_mask, intr_mask);

		REG_WR(timer, regi_timer0, rw_intr_mask, intr_mask);

    fast_timers_started++;

    fast_timer_running = 1;

  }

  else

  {

	} else {

    /* We have passed the time, disable trig point, ack intr */

    trig_cfg.tmr = regk_timer_off;

    REG_WR(timer, regi_timer, rw_trig_cfg, trig_cfg);

    REG_WR(timer, regi_timer, rw_ack_intr, ack_intr);

    /* call the int routine directly */

    timer_trig_handler();

		REG_WR(timer, regi_timer0, rw_trig_cfg, trig_cfg);

		REG_WR(timer, regi_timer0, rw_ack_intr, ack_intr);

		/* call the int routine */

		INIT_WORK(&fast_work, timer_trig_handler);

		schedule_work(&fast_work);

  }

}

  tmp = fast_timer_list;

  SANITYCHECK({ /* Check so this is not in the list already... */

    while (tmp != NULL)

    {

      if (tmp == t)

      {

        printk("timer name: %s data: 0x%08lX already in list!\n", name, data);

	while (tmp != NULL) {

		if (tmp == t) {

			printk(KERN_DEBUG

				"timer name: %s data: 0x%08lX already "

				"in list!\n", name, data);

			sanity_failed++;

        return;

      }

      else

      {

			goto done;

		} else

        tmp = tmp->next;

    }

    }

    tmp = fast_timer_list;

  });

  t->name = name;

  t->tv_expires.tv_usec = t->tv_set.tv_usec + delay_us % 1000000;

  t->tv_expires.tv_sec  = t->tv_set.tv_sec  + delay_us / 1000000;

  if (t->tv_expires.tv_usec > 1000000)

  {

	t->tv_expires.tv_jiff = t->tv_set.tv_jiff + delay_us / 1000000 / HZ;

	if (t->tv_expires.tv_usec > 1000000) {

    t->tv_expires.tv_usec -= 1000000;

    t->tv_expires.tv_sec++;

		t->tv_expires.tv_jiff += HZ;

  }

#ifdef FAST_TIMER_LOG

  timer_added_log[fast_timers_added % NUM_TIMER_STATS] = *t;

  fast_timers_added++;

  /* Check if this should timeout before anything else */

  if (tmp == NULL || timeval_cmp(&t->tv_expires, &tmp->tv_expires) < 0)

  {

  if (tmp == NULL || fasttime_cmp(&t->tv_expires, &tmp->tv_expires) < 0) {

    /* Put first in list and modify the timer value */

    t->prev = NULL;

    t->next = fast_timer_list;

    if (fast_timer_list)

    {

      fast_timer_list->prev = t;

    }

    fast_timer_list = t;

#ifdef FAST_TIMER_LOG

    timer_started_log[fast_timers_started % NUM_TIMER_STATS] = *t;

  } else {

    /* Put in correct place in list */

    while (tmp->next &&

           timeval_cmp(&t->tv_expires, &tmp->next->tv_expires) > 0)

    {

        fasttime_cmp(&t->tv_expires, &tmp->next->tv_expires) > 0)

      tmp = tmp->next;

    }

    /* Insert t after tmp */

    t->prev = tmp;

    t->next = tmp->next;

  D2(printk("start_one_shot_timer: %d us done\n", delay_us));

done:

  local_irq_restore(flags);

} /* start_one_shot_timer */

/* Timer interrupt handler for trig interrupts */

static irqreturn_t

timer_trig_interrupt(int irq, void *dev_id, struct pt_regs *regs)

timer_trig_interrupt(int irq, void *dev_id)

{

  reg_timer_r_masked_intr masked_intr;

  /* Check if the timer interrupt is for us (a trig int) */

  masked_intr = REG_RD(timer, regi_timer, r_masked_intr);

	masked_intr = REG_RD(timer, regi_timer0, r_masked_intr);

  if (!masked_intr.trig)

    return IRQ_NONE;

  timer_trig_handler();

	timer_trig_handler(NULL);

  return IRQ_HANDLED;

}

static void timer_trig_handler(void)

static void timer_trig_handler(struct work_struct *work)

{

  reg_timer_rw_ack_intr ack_intr = { 0 };

  reg_timer_rw_intr_mask intr_mask;

  struct fast_timer *t;

  unsigned long flags;

	/* We keep interrupts disabled not only when we modify the

	 * fast timer list, but any time we hold a reference to a

	 * timer in the list, since del_fast_timer may be called

	 * from (another) interrupt context.  Thus, the only time

	 * when interrupts are enabled is when calling the timer

	 * callback function.

	 */

  local_irq_save(flags);

  /* Clear timer trig interrupt */

  intr_mask = REG_RD(timer, regi_timer, rw_intr_mask);

	intr_mask = REG_RD(timer, regi_timer0, rw_intr_mask);

  intr_mask.trig = 0;

  REG_WR(timer, regi_timer, rw_intr_mask, intr_mask);

  REG_WR(timer, regi_timer0, rw_intr_mask, intr_mask);

  /* First stop timer, then ack interrupt */

  /* Stop timer */

  trig_cfg.tmr = regk_timer_off;

  REG_WR(timer, regi_timer, rw_trig_cfg, trig_cfg);

	REG_WR(timer, regi_timer0, rw_trig_cfg, trig_cfg);

  /* Ack interrupt */

  ack_intr.trig = 1;

  REG_WR(timer, regi_timer, rw_ack_intr, ack_intr);

	REG_WR(timer, regi_timer0, rw_ack_intr, ack_intr);

  fast_timer_running = 0;

  fast_timer_ints++;

  local_irq_restore(flags);

	fast_timer_function_type *f;

	unsigned long d;

  t = fast_timer_list;

  while (t)

  {

    struct timeval tv;

	while (t) {

		struct fasttime_t tv;

    /* Has it really expired? */

    do_gettimeofday_fast(&tv);

    D1(printk("t: %is %06ius\n", tv.tv_sec, tv.tv_usec));

		D1(printk(KERN_DEBUG

			"t: %is %06ius\n", tv.tv_jiff, tv.tv_usec));

    if (timeval_cmp(&t->tv_expires, &tv) <= 0)

    {

		if (fasttime_cmp(&t->tv_expires, &tv) <= 0) {

      /* Yes it has expired */

#ifdef FAST_TIMER_LOG

      timer_expired_log[fast_timers_expired % NUM_TIMER_STATS] = *t;

      fast_timers_expired++;

      /* Remove this timer before call, since it may reuse the timer */

      local_irq_save(flags);

      if (t->prev)

      {

        t->prev->next = t->next;

      }

      else

      {

        fast_timer_list = t->next;

      }

      if (t->next)

      {

        t->next->prev = t->prev;

      }

      t->prev = NULL;

      t->next = NULL;

      local_irq_restore(flags);

      if (t->function != NULL)

      {

        t->function(t->data);

      }

      else

      {

			/* Save function callback data before enabling

			 * interrupts, since the timer may be removed and we

			 * don't know how it was allocated (e.g. ->function

			 * and ->data may become overwritten after deletion

			 * if the timer was stack-allocated).

			 */

			f = t->function;

			d = t->data;

			if (f != NULL) {

				/* Run the callback function with interrupts

				 * enabled. */

				local_irq_restore(flags);

				f(d);

				local_irq_save(flags);

			} else

        DEBUG_LOG("!trimertrig %i function==NULL!\n", fast_timer_ints);

      }

    }

    else

    {

		} else {

      /* Timer is to early, let's set it again using the normal routines */

      D1(printk(".\n"));

    }

    local_irq_save(flags);

    if ((t = fast_timer_list) != NULL)

    {

		t = fast_timer_list;

		if (t != NULL) {

      /* Start next timer.. */

      long us;

      struct timeval tv;

			long us = 0;

			struct fasttime_t tv;

      do_gettimeofday_fast(&tv);

      us = ((t->tv_expires.tv_sec - tv.tv_sec) * 1000000 +

            t->tv_expires.tv_usec - tv.tv_usec);

      if (us > 0)

      {

        if (!fast_timer_running)

        {

			/* time_after_eq takes care of wrapping */

			if (time_after_eq(t->tv_expires.tv_jiff, tv.tv_jiff))

				us = ((t->tv_expires.tv_jiff - tv.tv_jiff) *

					1000000 / HZ + t->tv_expires.tv_usec -

					tv.tv_usec);

			if (us > 0) {

				if (!fast_timer_running) {

#ifdef FAST_TIMER_LOG

          timer_started_log[fast_timers_started % NUM_TIMER_STATS] = *t;

#endif

          start_timer_trig(us);

        }

        local_irq_restore(flags);

        break;

      }

      else

      {

			} else {

        /* Timer already expired, let's handle it better late than never.

         * The normal loop handles it

         */

        D1(printk("e! %d\n", us));

      }

    }

    local_irq_restore(flags);

  }

	local_irq_restore(flags);

	if (!t)

  {

    D1(printk("ttrig stop!\n"));

}

}

static void wake_up_func(unsigned long data)

{

#ifdef DECLARE_WAITQUEUE

  wait_queue_head_t  *sleep_wait_p = (wait_queue_head_t*)data;

#else

  struct wait_queue **sleep_wait_p = (struct wait_queue **)data;

#endif

  wake_up(sleep_wait_p);

}

void schedule_usleep(unsigned long us)

{

  struct fast_timer t;

#ifdef DECLARE_WAITQUEUE

  wait_queue_head_t sleep_wait;

  init_waitqueue_head(&sleep_wait);

  {

  DECLARE_WAITQUEUE(wait, current);

#else

  struct wait_queue *sleep_wait = NULL;

  struct wait_queue wait = { current, NULL };

#endif

  D1(printk("schedule_usleep(%d)\n", us));

  add_wait_queue(&sleep_wait, &wait);

  set_current_state(TASK_INTERRUPTIBLE);

  start_one_shot_timer(&t, wake_up_func, (unsigned long)&sleep_wait, us,

                       "usleep");

  schedule();

  set_current_state(TASK_RUNNING);

  remove_wait_queue(&sleep_wait, &wait);

	/* Uninterruptible sleep on the fast timer. (The condition is

	 * somewhat redundant since the timer is what wakes us up.) */

	wait_event(sleep_wait, !fast_timer_pending(&t));

  D1(printk("done schedule_usleep(%d)\n", us));

#ifdef DECLARE_WAITQUEUE

  }

#endif

}

#ifdef CONFIG_PROC_FS

  unsigned long flags;

  int i = 0;

  int num_to_show;

  struct timeval tv;

	struct fasttime_t tv;

  struct fast_timer *t, *nextt;

  static char *bigbuf = NULL;

  static unsigned long used;

  if (!bigbuf && !(bigbuf = vmalloc(BIG_BUF_SIZE)))

  {

	if (!bigbuf) {

		bigbuf = vmalloc(BIG_BUF_SIZE);

		if (!bigbuf) {

			used = 0;

    bigbuf[0] = '\0';

			if (buf)

				buf[0] = '\0';

			return 0;

		}

	}

  if (!offset || !used)

  {

	if (!offset || !used) {

    do_gettimeofday_fast(&tv);

    used = 0;

    used += sprintf(bigbuf + used, "Fast timer running:    %s\n",

                    fast_timer_running ? "yes" : "no");

    used += sprintf(bigbuf + used, "Current time:          %lu.%06lu\n",

                    (unsigned long)tv.tv_sec,

			(unsigned long)tv.tv_jiff,

                    (unsigned long)tv.tv_usec);

#ifdef FAST_TIMER_SANITY_CHECKS

    used += sprintf(bigbuf + used, "Sanity failed:         %i\n",

      i = 0;

			if (debug_log_cnt_wrapped)

      {

        i = debug_log_cnt;

      }

      while ((i != end_i || (debug_log_cnt_wrapped && !used)) &&

             used+100 < BIG_BUF_SIZE)

                      "d: %6li us data: 0x%08lX"

                      "\n",

                      t->name,

                      (unsigned long)t->tv_set.tv_sec,

				(unsigned long)t->tv_set.tv_jiff,

                      (unsigned long)t->tv_set.tv_usec,

                      (unsigned long)t->tv_expires.tv_sec,

				(unsigned long)t->tv_expires.tv_jiff,

                      (unsigned long)t->tv_expires.tv_usec,

                      t->delay_us,

                      t->data

                      "d: %6li us data: 0x%08lX"

                      "\n",

                      t->name,

                      (unsigned long)t->tv_set.tv_sec,

				(unsigned long)t->tv_set.tv_jiff,

                      (unsigned long)t->tv_set.tv_usec,