/*	$NetBSD: imxclock.c,v 1.9 2020/05/29 12:30:38 rin Exp $ */
/*
 * Copyright (c) 2009, 2010  Genetec corp.  All rights reserved.
 * Written by Hashimoto Kenichi for Genetec corp.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY GENETEC CORP. ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL GENETEC CORP.
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * common part for i.MX31 and i.MX51
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: imxclock.c,v 1.9 2020/05/29 12:30:38 rin Exp $");

#include "opt_imx.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/evcnt.h>
#include <sys/atomic.h>
#include <sys/time.h>
#include <sys/timetc.h>

#include <sys/types.h>
#include <sys/device.h>

#include <machine/intr.h>
#include <sys/bus.h>

#include <arm/cpu.h>
#include <arm/armreg.h>
#include <arm/cpufunc.h>

#include <arm/imx/imxclockvar.h>
#include <arm/imx/imxepitreg.h>

static u_int imx_epit_get_timecount(struct timecounter *);
static int imxclock_intr(void *);

static struct timecounter imx_epit_timecounter = {
	.tc_get_timecount = imx_epit_get_timecount,
	.tc_counter_mask = 0xffffffff,
	.tc_name = "epit",
	.tc_quality = 100,
};

static volatile uint32_t imxclock_base;
struct imxclock_softc *imxclock = NULL;

void
cpu_initclocks(void)
{
	uint32_t reg;
	u_int freq;

	if (epit1_sc != NULL)
		imxclock = epit1_sc;
	else if (epit2_sc != NULL)
		imxclock = epit2_sc;
	else
		panic("%s: driver has not been initialized!", __FUNCTION__);

	freq = imxclock_get_timerfreq(imxclock);
	imx_epit_timecounter.tc_frequency = freq;
	tc_init(&imx_epit_timecounter);

	aprint_verbose_dev(imxclock->sc_dev,
	    "timer clock frequency %d\n", freq);

	imxclock->sc_reload_value = freq / hz - 1;

	/* stop timers */
	bus_space_write_4(imxclock->sc_iot, imxclock->sc_ioh, EPIT_EPITCR, 0);

	aprint_normal("clock: hz=%d stathz = %d\n", hz, stathz);

	bus_space_write_4(imxclock->sc_iot, imxclock->sc_ioh, EPIT_EPITLR,
			  imxclock->sc_reload_value);
	bus_space_write_4(imxclock->sc_iot, imxclock->sc_ioh, EPIT_EPITCMPR, 0);

	reg = EPITCR_ENMOD | EPITCR_IOVW | EPITCR_RLD | imxclock->sc_clksrc;
	bus_space_write_4(imxclock->sc_iot, imxclock->sc_ioh,
	    EPIT_EPITCR, reg);
	reg |= EPITCR_EN | EPITCR_OCIEN | EPITCR_WAITEN | EPITCR_DOZEN |
		EPITCR_STOPEN;
	bus_space_write_4(imxclock->sc_iot, imxclock->sc_ioh,
	    EPIT_EPITCR, reg);

	imxclock->sc_ih = intr_establish(imxclock->sc_intr, IPL_CLOCK,
	    IST_LEVEL, imxclock_intr, NULL);
}

void
setstatclockrate(int schz)
{
}

static int
imxclock_intr(void *arg)
{
	struct imxclock_softc *sc = imxclock;

	bus_space_write_4(sc->sc_iot, sc->sc_ioh, EPIT_EPITSR, 1);
	atomic_add_32(&imxclock_base, sc->sc_reload_value);

	hardclock((struct clockframe *)arg);

	return 1;
}

u_int
imx_epit_get_timecount(struct timecounter *tc)
{
	uint32_t counter;
	uint32_t base;
	u_int oldirqstate;

	oldirqstate = disable_interrupts(I32_bit);
	counter = bus_space_read_4(imxclock->sc_iot, imxclock->sc_ioh, EPIT_EPITCNT);
	base = imxclock_base;
	restore_interrupts(oldirqstate);

	return base - counter;
}