/*
 * Copyright 2003-2011 NetLogic Microsystems, Inc. (NetLogic). All rights
 * reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the NetLogic
 * license below:
 *
 * 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 NETLOGIC ``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 NETLOGIC OR CONTRIBUTORS 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.
 */

#include <linux/init.h>

#include <asm/time.h>
#include <asm/cpu-features.h>

#include <asm/netlogic/interrupt.h>
#include <asm/netlogic/common.h>
#include <asm/netlogic/haldefs.h>
#include <asm/netlogic/common.h>

#if defined(CONFIG_CPU_XLP)
#include <asm/netlogic/xlp-hal/iomap.h>
#include <asm/netlogic/xlp-hal/xlp.h>
#include <asm/netlogic/xlp-hal/pic.h>
#elif defined(CONFIG_CPU_XLR)
#include <asm/netlogic/xlr/iomap.h>
#include <asm/netlogic/xlr/pic.h>
#include <asm/netlogic/xlr/xlr.h>
#else
#error "Unknown CPU"
#endif

unsigned int __cpuinit get_c0_compare_int(void)
{
	return IRQ_TIMER;
}

static cycle_t nlm_get_pic_timer(struct clocksource *cs)
{
	uint64_t picbase = nlm_get_node(0)->picbase;

	return ~nlm_pic_read_timer(picbase, PIC_CLOCK_TIMER);
}

static cycle_t nlm_get_pic_timer32(struct clocksource *cs)
{
	uint64_t picbase = nlm_get_node(0)->picbase;

	return ~nlm_pic_read_timer32(picbase, PIC_CLOCK_TIMER);
}

static struct clocksource csrc_pic = {
	.name		= "PIC",
	.flags		= CLOCK_SOURCE_IS_CONTINUOUS,
};

static void nlm_init_pic_timer(void)
{
	uint64_t picbase = nlm_get_node(0)->picbase;

	nlm_pic_set_timer(picbase, PIC_CLOCK_TIMER, ~0ULL, 0, 0);
	if (current_cpu_data.cputype == CPU_XLR) {
		csrc_pic.mask	= CLOCKSOURCE_MASK(32);
		csrc_pic.read	= nlm_get_pic_timer32;
	} else {
		csrc_pic.mask	= CLOCKSOURCE_MASK(64);
		csrc_pic.read	= nlm_get_pic_timer;
	}
	csrc_pic.rating = 1000;
	clocksource_register_hz(&csrc_pic, PIC_CLK_HZ);
}

void __init plat_time_init(void)
{
	nlm_init_pic_timer();
	mips_hpt_frequency = nlm_get_cpu_frequency();
	if (current_cpu_type() == CPU_XLR)
		preset_lpj = mips_hpt_frequency / (3 * HZ);
	else
		preset_lpj = mips_hpt_frequency / (2 * HZ);
	pr_info("MIPS counter frequency [%ld]\n",
			(unsigned long)mips_hpt_frequency);
}
