/*
 * Copyright (C) 2007 David S. Miller (davem@davemloft.net)
 *
 * Based upon gen_powerpc code which is:
 * Copyright (C) IBM Corporation, 2007.  All rights reserved.
 * Contributed by Corey Ashford (cjashfor@us.ibm.com)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 *
 * pfmlib_sparc.c
 *
 * Support for libpfm for Sparc processors.
 */

#ifndef _GNU_SOURCE
  #define _GNU_SOURCE /* for getline */
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

/* private headers */
#include "pfmlib_priv.h"

#include "pfmlib_sparc_priv.h"

#include "ultra12_events.h"
#include "ultra3_events.h"
#include "ultra3i_events.h"
#include "ultra3plus_events.h"
#include "ultra4plus_events.h"
#include "niagara1_events.h"
#include "niagara2_events.h"

static char *get_event_name(int event)
{
	switch (sparc_support.pmu_type) {
	case PFMLIB_SPARC_ULTRA12_PMU:
		return ultra12_pe[event].pme_name;
	case PFMLIB_SPARC_ULTRA3_PMU:
		return ultra3_pe[event].pme_name;
	case PFMLIB_SPARC_ULTRA3I_PMU:
		return ultra3i_pe[event].pme_name;
	case PFMLIB_SPARC_ULTRA3PLUS_PMU:
		return ultra3plus_pe[event].pme_name;
	case PFMLIB_SPARC_ULTRA4PLUS_PMU:
		return ultra4plus_pe[event].pme_name;
	case PFMLIB_SPARC_NIAGARA1_PMU:
		return niagara1_pe[event].pme_name;
	case PFMLIB_SPARC_NIAGARA2_PMU:
		return niagara2_pe[event].pme_name;
	}
	return (char *)-1;
}

static char *get_event_desc(int event)
{
	switch (sparc_support.pmu_type) {
	case PFMLIB_SPARC_ULTRA12_PMU:
		return ultra12_pe[event].pme_desc;
	case PFMLIB_SPARC_ULTRA3_PMU:
		return ultra3_pe[event].pme_desc;
	case PFMLIB_SPARC_ULTRA3I_PMU:
		return ultra3i_pe[event].pme_desc;
	case PFMLIB_SPARC_ULTRA3PLUS_PMU:
		return ultra3plus_pe[event].pme_desc;
	case PFMLIB_SPARC_ULTRA4PLUS_PMU:
		return ultra4plus_pe[event].pme_desc;
	case PFMLIB_SPARC_NIAGARA1_PMU:
		return niagara1_pe[event].pme_desc;
	case PFMLIB_SPARC_NIAGARA2_PMU:
		return niagara2_pe[event].pme_desc;
	}
	return (char *)-1;
}

static char get_ctrl(int event)
{
	switch (sparc_support.pmu_type) {
	case PFMLIB_SPARC_ULTRA12_PMU:
		return ultra12_pe[event].pme_ctrl;
	case PFMLIB_SPARC_ULTRA3_PMU:
		return ultra3_pe[event].pme_ctrl;
	case PFMLIB_SPARC_ULTRA3I_PMU:
		return ultra3i_pe[event].pme_ctrl;
	case PFMLIB_SPARC_ULTRA3PLUS_PMU:
		return ultra3plus_pe[event].pme_ctrl;
	case PFMLIB_SPARC_ULTRA4PLUS_PMU:
		return ultra4plus_pe[event].pme_ctrl;
	case PFMLIB_SPARC_NIAGARA1_PMU:
		return niagara1_pe[event].pme_ctrl;
	case PFMLIB_SPARC_NIAGARA2_PMU:
		return niagara2_pe[event].pme_ctrl;
	}
	return 0xff;
}

static int get_val(int event)
{
	switch (sparc_support.pmu_type) {
	case PFMLIB_SPARC_ULTRA12_PMU:
		return ultra12_pe[event].pme_val;
	case PFMLIB_SPARC_ULTRA3_PMU:
		return ultra3_pe[event].pme_val;
	case PFMLIB_SPARC_ULTRA3I_PMU:
		return ultra3i_pe[event].pme_val;
	case PFMLIB_SPARC_ULTRA3PLUS_PMU:
		return ultra3plus_pe[event].pme_val;
	case PFMLIB_SPARC_ULTRA4PLUS_PMU:
		return ultra4plus_pe[event].pme_val;
	case PFMLIB_SPARC_NIAGARA1_PMU:
		return niagara1_pe[event].pme_val;
	case PFMLIB_SPARC_NIAGARA2_PMU:
		return niagara2_pe[event].pme_val;
	}
	return -1;
}

static int pfm_sparc_get_event_code(unsigned int event,
				    unsigned int pmd,
				    int *code)
{
        *code = get_val(event);
	return 0;
}

static char *pfm_sparc_get_event_name(unsigned int event)
{
	return get_event_name(event);
}

static char *pfm_sparc_get_event_mask_name(unsigned int event,
					   unsigned int mask)
{
	pme_sparc_mask_entry_t *e;

	if (sparc_support.pmu_type != PFMLIB_SPARC_NIAGARA2_PMU)
		return "";

	e = &niagara2_pe[event];
	return e->pme_masks[mask].mask_name;
}

static void pfm_sparc_get_event_counters(unsigned int event,
					 pfmlib_regmask_t *counters)
{
	if (sparc_support.pmu_type == PFMLIB_SPARC_NIAGARA2_PMU) {
		counters->bits[0] = (1 << 0) | (1 << 1);
	} else {
		char ctrl = get_ctrl(event);

		counters->bits[0] = 0;	
		if (ctrl & PME_CTRL_S0)
			counters->bits[0] |= (1 << 0);
		if (ctrl & PME_CTRL_S1)
			counters->bits[0] |= (1 << 1);
	}
}

static unsigned int pfm_sparc_get_num_event_masks(unsigned int event)
{
	if (sparc_support.pmu_type != PFMLIB_SPARC_NIAGARA2_PMU)
		return 0;
	return (event == 0 ? 0 : EVENT_MASK_BITS);
}

/* Bits common to all PCR implementations */
#define PCR_PRIV	(0x1UL << 0)
#define PCR_SYS_TRACE	(0x1UL << 1)
#define PCR_USER_TRACE	(0x1UL << 2)

/* The S0 and S1 fields determine which events are monitored in
 * the assosciated PIC (PIC0 vs. PIC1 respectively).  For ultra12
 * these fields are 4 bits, on ultra3/3i/3+/4+ they are 6 bits.
 * For Niagara-1 there is only S0 and it is 3 bits in size.
 * Niagara-1's PIC1 is hard-coded to record retired instructions.
 */
#define PCR_S0_SHIFT		4
#define PCR_S0			(0x1fUL << PCR_S0_SHIFT)
#define PCR_S1_SHIFT		11
#define PCR_S1			(0x1fUL << PCR_S1_SHIFT)

/* Niagara-2 specific PCR bits.  It supports event masking.  */
#define PCR_N2_HYP_TRACE	(0x1UL << 3)
#define PCR_N2_TOE0		(0x1UL << 4)
#define PCR_N2_TOE1		(0x1UL << 5)
#define PCR_N2_SL0_SHIFT	14
#define PCR_N2_SL0		(0xf << PCR_N2_SL0_SHIFT)
#define PCR_N2_MASK0_SHIFT	6
#define PCR_N2_MASK0		(0xff << PCR_N2_MASK0_SHIFT)
#define PCR_N2_SL1_SHIFT	27
#define PCR_N2_SL1		(0xf << PCR_N2_SL1_SHIFT)
#define PCR_N2_MASK1_SHIFT	19
#define PCR_N2_MASK1		(0xff << PCR_N2_MASK1_SHIFT)

static int pfm_sparc_dispatch_events(pfmlib_input_param_t *input,
				     void *model_input,
				     pfmlib_output_param_t *output,
				     void *model_output)
{
	unsigned long long pcr, vals[2];
	unsigned int plm, i;
	int niagara2;
	char ctrls[2];

	if (input->pfp_event_count > 2)
		return PFMLIB_ERR_TOOMANY;

	plm = ((input->pfp_events[0].plm != 0) ?
	       input->pfp_events[0].plm :
	       input->pfp_dfl_plm);
	for (i = 1; i < input->pfp_event_count; i++) {
		if (input->pfp_events[i].plm == 0) {
			/* it's ok if the default is the same as plm */
			if (plm != input->pfp_dfl_plm) 
				return PFMLIB_ERR_NOASSIGN;
		} else {
			if (plm != input->pfp_events[i].plm)
				return PFMLIB_ERR_NOASSIGN;
		}
	}

	niagara2 = 0;
	if (sparc_support.pmu_type == PFMLIB_SPARC_NIAGARA2_PMU)
		niagara2 = 1;

	pcr = 0;
	if (plm & PFM_PLM3)
		pcr |= PCR_USER_TRACE;
	if (plm & PFM_PLM0)
		pcr |= PCR_SYS_TRACE;
	if (niagara2 && (plm & PFM_PLM1))
		pcr |= PCR_N2_HYP_TRACE;

	for (i = 0; i < input->pfp_event_count; i++) {
		pfmlib_event_t *e = &input->pfp_events[i];

		ctrls[i] = get_ctrl(e->event);
		vals[i] = get_val(e->event);

		if (i == 1) {
			if ((ctrls[0] & ctrls[1]) == 0)
				continue;

			if (ctrls[0] == (PME_CTRL_S0|PME_CTRL_S1)) {
				if (ctrls[1] == (PME_CTRL_S0|PME_CTRL_S1)) {
					ctrls[0] = PME_CTRL_S0;
					ctrls[1] = PME_CTRL_S1;
				} else {
					ctrls[0] &= ~ctrls[1];
				}
			} else if (ctrls[1] == (PME_CTRL_S0|PME_CTRL_S1)) {
				ctrls[1] &= ~ctrls[0];
			} else
				return PFMLIB_ERR_INVAL;
		}
	}

	if (input->pfp_event_count == 1) {
		if (ctrls[0] == (PME_CTRL_S0|PME_CTRL_S1))
			ctrls[0] = PME_CTRL_S0;
	}

	for (i = 0; i < input->pfp_event_count; i++) {
		unsigned long long val = vals[i];
		char ctrl = ctrls[i];

		switch (ctrl) {
		case PME_CTRL_S0:
			output->pfp_pmds[i].reg_num = 0;
			pcr |= (val <<
				(niagara2 ?
				 PCR_N2_SL0_SHIFT :
				 PCR_S0_SHIFT));
			break;

		case PME_CTRL_S1:
			output->pfp_pmds[i].reg_num = 1;
			pcr |= (val <<
				(niagara2 ?
				 PCR_N2_SL1_SHIFT :
				 PCR_S1_SHIFT));
			break;

		default:
			return PFMLIB_ERR_INVAL;
		}
		if (niagara2) {
			pfmlib_event_t *e = &input->pfp_events[i];
			unsigned int j, shift;

			if (ctrl == PME_CTRL_S0) {
				pcr |= PCR_N2_TOE0;
				shift = PCR_N2_MASK0_SHIFT;
			} else {
				pcr |= PCR_N2_TOE1;
				shift = PCR_N2_MASK1_SHIFT;
			}
			for (j = 0; j < e->num_masks; j++) {
				unsigned int mask;

				mask = e->unit_masks[j];
				if (mask >= EVENT_MASK_BITS)
					return PFMLIB_ERR_INVAL;
				pcr |= (1ULL << (shift + mask));
			}
		}

		output->pfp_pmds[i].reg_value = 0;
		output->pfp_pmds[i].reg_addr = 0;
		output->pfp_pmds[i].reg_alt_addr = 0;
		output->pfp_pmds[i].reg_reserved1 = 0;
		output->pfp_pmd_count = i + 1;
	}

	output->pfp_pmcs[0].reg_value = pcr;
	output->pfp_pmcs[0].reg_addr = 0;
	output->pfp_pmcs[0].reg_num = 0;
	output->pfp_pmcs[0].reg_reserved1 = 0;
	output->pfp_pmc_count = 1;
		
	return PFMLIB_SUCCESS;
}

static int pmu_name_to_pmu_type(char *name)
{
	if (!strcmp(name, "ultra12"))
		return PFMLIB_SPARC_ULTRA12_PMU;
	if (!strcmp(name, "ultra3"))
		return PFMLIB_SPARC_ULTRA3_PMU;
	if (!strcmp(name, "ultra3i"))
		return PFMLIB_SPARC_ULTRA3I_PMU;
	if (!strcmp(name, "ultra3+"))
		return PFMLIB_SPARC_ULTRA3PLUS_PMU;
	if (!strcmp(name, "ultra4+"))
		return PFMLIB_SPARC_ULTRA4PLUS_PMU;
	if (!strcmp(name, "niagara2"))
		return PFMLIB_SPARC_NIAGARA2_PMU;
	if (!strcmp(name, "niagara"))
		return PFMLIB_SPARC_NIAGARA1_PMU;
	return -1;
}

static int pfm_sparc_pmu_detect(void)
{
	int ret, pmu_type, pme_count;
	char buffer[32];

	ret = __pfm_getcpuinfo_attr("pmu", buffer, sizeof(buffer));
	if (ret == -1)
		return PFMLIB_ERR_NOTSUPP;

	pmu_type = pmu_name_to_pmu_type(buffer);
	if (pmu_type == -1)
		return PFMLIB_ERR_NOTSUPP;

	switch (pmu_type) {
	default:
		return PFMLIB_ERR_NOTSUPP;

	case PFMLIB_SPARC_ULTRA12_PMU:
		pme_count = PME_ULTRA12_EVENT_COUNT;
		break;

	case PFMLIB_SPARC_ULTRA3_PMU:
		pme_count = PME_ULTRA3_EVENT_COUNT;
		break;

	case PFMLIB_SPARC_ULTRA3I_PMU:
		pme_count = PME_ULTRA3I_EVENT_COUNT;
		break;

	case PFMLIB_SPARC_ULTRA3PLUS_PMU:
		pme_count = PME_ULTRA3PLUS_EVENT_COUNT;
		break;

	case PFMLIB_SPARC_ULTRA4PLUS_PMU:
		pme_count = PME_ULTRA4PLUS_EVENT_COUNT;
		break;

	case PFMLIB_SPARC_NIAGARA1_PMU:
		pme_count = PME_NIAGARA1_EVENT_COUNT;
		break;

	case PFMLIB_SPARC_NIAGARA2_PMU:
		pme_count = PME_NIAGARA2_EVENT_COUNT;
		break;
	}

	sparc_support.pmu_type = pmu_type;
	sparc_support.pmu_name = strdup(buffer);
	sparc_support.pme_count = pme_count;

	return PFMLIB_SUCCESS;
}

static void pfm_sparc_get_impl_pmcs(pfmlib_regmask_t *impl_pmcs)
{
        impl_pmcs->bits[0] = 0x1;
}

static void pfm_sparc_get_impl_pmds(pfmlib_regmask_t *impl_pmds)
{
        impl_pmds->bits[0] = 0x3;
}

static void pfm_sparc_get_impl_counters(pfmlib_regmask_t *impl_counters)
{
	pfm_sparc_get_impl_pmds(impl_counters);
}

static void pfm_sparc_get_hw_counter_width(unsigned int *width)
{
	*width = 32;
}

static int pfm_sparc_get_event_desc(unsigned int event, char **desc)
{
	*desc = strdup(get_event_desc(event));
	return 0;
}

static int pfm_sparc_get_event_mask_desc(unsigned int event,
					 unsigned int mask, char **desc)
{
	if (sparc_support.pmu_type != PFMLIB_SPARC_NIAGARA2_PMU) {
		*desc = strdup("");
	} else {
		pme_sparc_mask_entry_t *e;

		e = &niagara2_pe[event];
		*desc = strdup(e->pme_masks[mask].mask_desc);
	}
	return 0;
}

static int pfm_sparc_get_event_mask_code(unsigned int event,
					 unsigned int mask, unsigned int *code)
{
	if (sparc_support.pmu_type != PFMLIB_SPARC_NIAGARA2_PMU)
		*code = 0;
	else
		*code = mask;
	return 0;
}

static int
pfm_sparc_get_cycle_event(pfmlib_event_t *e)
{
	switch (sparc_support.pmu_type) {
	case PFMLIB_SPARC_ULTRA12_PMU:
	case PFMLIB_SPARC_ULTRA3_PMU:
	case PFMLIB_SPARC_ULTRA3I_PMU:
	case PFMLIB_SPARC_ULTRA3PLUS_PMU:
	case PFMLIB_SPARC_ULTRA4PLUS_PMU:
		e->event = 0;
		break;

	case PFMLIB_SPARC_NIAGARA1_PMU:
	case PFMLIB_SPARC_NIAGARA2_PMU:
	default:
		return PFMLIB_ERR_NOTSUPP;
	}

	return PFMLIB_SUCCESS;
}

static int
pfm_sparc_get_inst_retired(pfmlib_event_t *e)
{
	unsigned int i;

	switch (sparc_support.pmu_type) {
	case PFMLIB_SPARC_ULTRA12_PMU:
	case PFMLIB_SPARC_ULTRA3_PMU:
	case PFMLIB_SPARC_ULTRA3I_PMU:
	case PFMLIB_SPARC_ULTRA3PLUS_PMU:
	case PFMLIB_SPARC_ULTRA4PLUS_PMU:
		e->event = 1;
		break;

	case PFMLIB_SPARC_NIAGARA1_PMU:
		e->event = 0;
		break;

	case PFMLIB_SPARC_NIAGARA2_PMU:
		e->event = 1;
		e->num_masks = EVENT_MASK_BITS;
		for (i = 0; i < e->num_masks; i++)
			e->unit_masks[i] = i;
		break;

	default:
		return PFMLIB_ERR_NOTSUPP;
	}
	return PFMLIB_SUCCESS;
}

/**
 * sparc_support
 **/
pfm_pmu_support_t sparc_support = {
	/* the next 3 fields are initialized in pfm_sparc_pmu_detect */
	.pmu_name		= NULL,
	.pmu_type		= PFMLIB_UNKNOWN_PMU,
	.pme_count		= 0,

	.pmd_count		= 2,
	.pmc_count		= 1,
	.num_cnt		= 2,

	.get_event_code		= pfm_sparc_get_event_code,
	.get_event_name		= pfm_sparc_get_event_name,
	.get_event_mask_name	= pfm_sparc_get_event_mask_name,
	.get_event_counters	= pfm_sparc_get_event_counters,
	.get_num_event_masks	= pfm_sparc_get_num_event_masks,
	.dispatch_events	= pfm_sparc_dispatch_events,
	.pmu_detect		= pfm_sparc_pmu_detect,
	.get_impl_pmcs		= pfm_sparc_get_impl_pmcs,
	.get_impl_pmds		= pfm_sparc_get_impl_pmds,
	.get_impl_counters	= pfm_sparc_get_impl_counters,
	.get_hw_counter_width	= pfm_sparc_get_hw_counter_width,
	.get_event_desc         = pfm_sparc_get_event_desc,
	.get_event_mask_desc	= pfm_sparc_get_event_mask_desc,
	.get_event_mask_code	= pfm_sparc_get_event_mask_code,
	.get_cycle_event	= pfm_sparc_get_cycle_event,
	.get_inst_retired_event = pfm_sparc_get_inst_retired
};