/*
 *  Clock Tick Device Driver
 *
 *  This routine initializes LEON timer 1 which used for the clock tick.
 *
 *  The tick frequency is directly programmed to the configured number of
 *  microseconds per tick.
 *
 *  COPYRIGHT (c) 1989-2006.
 *  On-Line Applications Research Corporation (OAR).
 *
 *  Modified for LEON3 BSP.
 *  COPYRIGHT (c) 2004.
 *  Gaisler Research.
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.rtems.org/license/LICENSE.
 */

#include <bsp.h>
#include <bspopts.h>
#include <bsp/fatal.h>
#include <rtems/rtems/intr.h>
#include <ambapp.h>
#include <rtems/score/profiling.h>

/* The LEON3 BSP Timer driver can rely on the Driver Manager if the
 * DrvMgr is initialized during startup. Otherwise the classic driver
 * must be used.
 *
 * The DrvMgr Clock driver is located in the shared/timer directory
 */
#ifndef RTEMS_DRVMGR_STARTUP

#if SIMSPARC_FAST_IDLE==1
#define CLOCK_DRIVER_USE_FAST_IDLE 1
#endif

/* LEON3 Timer system interrupt number */
static int clkirq;

static void leon3_clock_profiling_interrupt_delay(void)
{
#ifdef RTEMS_PROFILING
  /*
   * We need a small state machine to ignore the first clock interrupt, since
   * it contains the sequential system initialization time.  Do the timestamp
   * initialization on the fly.
   */
  static int state = 1;

  volatile struct irqmp_timestamp_regs *irqmp_ts =
    &LEON3_IrqCtrl_Regs->timestamp[0];
  unsigned int s1_s2 = (1U << 25) | (1U << 26);

  if (state == 0) {
    unsigned int first = irqmp_ts->assertion;
    unsigned int second = irqmp_ts->counter;

    irqmp_ts->control |= s1_s2;

    _Profiling_Update_max_interrupt_delay(_Per_CPU_Get(), second - first);
  } else if (state == 1 && leon3_irqmp_has_timestamp(irqmp_ts)) {
    unsigned int ks = 1U << 5;

    state = 0;

    irqmp_ts->control = ks | s1_s2 | (unsigned int) clkirq;
  } else if (state == 1) {
    state = 2;
  }
#endif
}

#define Clock_driver_support_at_tick() \
  do { \
    leon3_clock_profiling_interrupt_delay(); \
  } while (0)

#define Adjust_clkirq_for_node() do { clkirq += LEON3_CLOCK_INDEX; } while(0)

#define Clock_driver_support_find_timer() \
  do { \
    /* Assume timer found during BSP initialization */ \
    if (LEON3_Timer_Regs) { \
      clkirq = (LEON3_Timer_Regs->cfg & 0xf8) >> 3; \
      \
      Adjust_clkirq_for_node(); \
    } \
  } while (0)

#define Clock_driver_support_install_isr( _new, _old ) \
  do { \
    (_old) = NULL; \
    bsp_clock_handler_install(_new); \
  } while(0)

static void bsp_clock_handler_install(rtems_isr *new)
{
  rtems_status_code sc;

  sc = rtems_interrupt_handler_install(
    clkirq,
    "Clock",
    RTEMS_INTERRUPT_UNIQUE,
    new,
    NULL
  );
  if (sc != RTEMS_SUCCESSFUL) {
    rtems_fatal(RTEMS_FATAL_SOURCE_BSP, LEON3_FATAL_CLOCK_INITIALIZATION);
  }
}

#define Clock_driver_support_initialize_hardware() \
  do { \
    LEON3_Timer_Regs->timer[LEON3_CLOCK_INDEX].reload = \
      rtems_configuration_get_microseconds_per_tick() - 1; \
    \
    LEON3_Timer_Regs->timer[LEON3_CLOCK_INDEX].ctrl = \
      GPTIMER_TIMER_CTRL_EN | GPTIMER_TIMER_CTRL_RS | \
        GPTIMER_TIMER_CTRL_LD | GPTIMER_TIMER_CTRL_IE; \
  } while (0)

#define Clock_driver_support_shutdown_hardware() \
  do { \
    LEON_Mask_interrupt(LEON_TRAP_TYPE(clkirq)); \
    LEON3_Timer_Regs->timer[LEON3_CLOCK_INDEX].ctrl = 0; \
  } while (0)

static uint32_t bsp_clock_nanoseconds_since_last_tick(void)
{
  uint32_t clicks;
  uint32_t usecs;

  if ( !LEON3_Timer_Regs )
    return 0;

  clicks = LEON3_Timer_Regs->timer[LEON3_CLOCK_INDEX].value;

  if ( LEON_Is_interrupt_pending( clkirq ) ) {
    clicks = LEON3_Timer_Regs->timer[LEON3_CLOCK_INDEX].value;
    usecs = (2*rtems_configuration_get_microseconds_per_tick() - clicks);
  } else {
    usecs = (rtems_configuration_get_microseconds_per_tick() - clicks);
  }
  return usecs * 1000;
}

#define Clock_driver_nanoseconds_since_last_tick \
        bsp_clock_nanoseconds_since_last_tick

#include "../../../shared/clockdrv_shell.h"

#endif