[mirror_ubuntu-bionic-kernel.git] / arch / powerpc / oprofile / common.c

/*
 * PPC 64 oprofile support:
 * Copyright (C) 2004 Anton Blanchard <anton@au.ibm.com>, IBM
 * PPC 32 oprofile support: (based on PPC 64 support)
 * Copyright (C) Freescale Semiconductor, Inc 2004
 *	Author: Andy Fleming
 *
 * Based on alpha version.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/oprofile.h>
#include <linux/init.h>
#include <linux/smp.h>
#include <linux/errno.h>
#include <asm/ptrace.h>
#include <asm/system.h>
#include <asm/pmc.h>
#include <asm/cputable.h>
#include <asm/oprofile_impl.h>
#include <asm/firmware.h>

static struct op_powerpc_model *model;

static struct op_counter_config ctr[OP_MAX_COUNTER];
static struct op_system_config sys;

static int op_per_cpu_rc;

static void op_handle_interrupt(struct pt_regs *regs)
{
	model->handle_interrupt(regs, ctr);
}

static void op_powerpc_cpu_setup(void *dummy)
{
	int ret;

	ret = model->cpu_setup(ctr);

	if (ret != 0)
		op_per_cpu_rc = ret;
}

static int op_powerpc_setup(void)
{
	int err;

	op_per_cpu_rc = 0;

	/* Grab the hardware */
	err = reserve_pmc_hardware(op_handle_interrupt);
	if (err)
		return err;

	/* Pre-compute the values to stuff in the hardware registers.  */
	op_per_cpu_rc = model->reg_setup(ctr, &sys, model->num_counters);

	if (op_per_cpu_rc)
		goto out;

	/* Configure the registers on all cpus.	 If an error occurs on one
	 * of the cpus, op_per_cpu_rc will be set to the error */
	on_each_cpu(op_powerpc_cpu_setup, NULL, 1);

out:	if (op_per_cpu_rc) {
		/* error on setup release the performance counter hardware */
		release_pmc_hardware();
	}

	return op_per_cpu_rc;
}

static void op_powerpc_shutdown(void)
{
	release_pmc_hardware();
}

static void op_powerpc_cpu_start(void *dummy)
{
	/* If any of the cpus have return an error, set the
	 * global flag to the error so it can be returned
	 * to the generic OProfile caller.
	 */
	int ret;

	ret = model->start(ctr);
	if (ret != 0)
		op_per_cpu_rc = ret;
}

static int op_powerpc_start(void)
{
	op_per_cpu_rc = 0;

	if (model->global_start)
		return model->global_start(ctr);
	if (model->start) {
		on_each_cpu(op_powerpc_cpu_start, NULL, 1);
		return op_per_cpu_rc;
	}
	return -EIO; /* No start function is defined for this
			power architecture */
}

static inline void op_powerpc_cpu_stop(void *dummy)
{
	model->stop();
}

static void op_powerpc_stop(void)
{
	if (model->stop)
		on_each_cpu(op_powerpc_cpu_stop, NULL, 1);
        if (model->global_stop)
                model->global_stop();
}

static int op_powerpc_create_files(struct super_block *sb, struct dentry *root)
{
	int i;

#ifdef CONFIG_PPC64
	/*
	 * There is one mmcr0, mmcr1 and mmcra for setting the events for
	 * all of the counters.
	 */
	oprofilefs_create_ulong(sb, root, "mmcr0", &sys.mmcr0);
	oprofilefs_create_ulong(sb, root, "mmcr1", &sys.mmcr1);
	oprofilefs_create_ulong(sb, root, "mmcra", &sys.mmcra);
#ifdef CONFIG_OPROFILE_CELL
	/* create a file the user tool can check to see what level of profiling
	 * support exits with this kernel. Initialize bit mask to indicate
	 * what support the kernel has:
	 * bit 0      -  Supports SPU event profiling in addition to PPU
	 *               event and cycles; and SPU cycle profiling
	 * bits 1-31  -  Currently unused.
	 *
	 * If the file does not exist, then the kernel only supports SPU
	 * cycle profiling, PPU event and cycle profiling.
	 */
	oprofilefs_create_ulong(sb, root, "cell_support", &sys.cell_support);
	sys.cell_support = 0x1; /* Note, the user OProfile tool must check
				 * that this bit is set before attempting to
				 * user SPU event profiling.  Older kernels
				 * will not have this file, hence the user
				 * tool is not allowed to do SPU event
				 * profiling on older kernels.  Older kernels
				 * will accept SPU events but collected data
				 * is garbage.
				 */
#endif
#endif

	for (i = 0; i < model->num_counters; ++i) {
		struct dentry *dir;
		char buf[4];

		snprintf(buf, sizeof buf, "%d", i);
		dir = oprofilefs_mkdir(sb, root, buf);

		oprofilefs_create_ulong(sb, dir, "enabled", &ctr[i].enabled);
		oprofilefs_create_ulong(sb, dir, "event", &ctr[i].event);
		oprofilefs_create_ulong(sb, dir, "count", &ctr[i].count);

		/*
		 * Classic PowerPC doesn't support per-counter
		 * control like this, but the options are
		 * expected, so they remain.  For Freescale
		 * Book-E style performance monitors, we do
		 * support them.
		 */
		oprofilefs_create_ulong(sb, dir, "kernel", &ctr[i].kernel);
		oprofilefs_create_ulong(sb, dir, "user", &ctr[i].user);

		oprofilefs_create_ulong(sb, dir, "unit_mask", &ctr[i].unit_mask);
	}

	oprofilefs_create_ulong(sb, root, "enable_kernel", &sys.enable_kernel);
	oprofilefs_create_ulong(sb, root, "enable_user", &sys.enable_user);

	/* Default to tracing both kernel and user */
	sys.enable_kernel = 1;
	sys.enable_user = 1;

	return 0;
}

int __init oprofile_arch_init(struct oprofile_operations *ops)
{
	if (!cur_cpu_spec->oprofile_cpu_type)
		return -ENODEV;

	if (firmware_has_feature(FW_FEATURE_ISERIES))
		return -ENODEV;

	switch (cur_cpu_spec->oprofile_type) {
#ifdef CONFIG_PPC_BOOK3S_64
#ifdef CONFIG_OPROFILE_CELL
		case PPC_OPROFILE_CELL:
			if (firmware_has_feature(FW_FEATURE_LPAR))
				return -ENODEV;
			model = &op_model_cell;
			ops->sync_start = model->sync_start;
			ops->sync_stop = model->sync_stop;
			break;
#endif
		case PPC_OPROFILE_RS64:
			model = &op_model_rs64;
			break;
		case PPC_OPROFILE_POWER4:
			model = &op_model_power4;
			break;
		case PPC_OPROFILE_PA6T:
			model = &op_model_pa6t;
			break;
#endif
#ifdef CONFIG_6xx
		case PPC_OPROFILE_G4:
			model = &op_model_7450;
			break;
#endif
#if defined(CONFIG_FSL_EMB_PERFMON)
		case PPC_OPROFILE_FSL_EMB:
			model = &op_model_fsl_emb;
			break;
#endif
		default:
			return -ENODEV;
	}

	model->num_counters = cur_cpu_spec->num_pmcs;

	ops->cpu_type = cur_cpu_spec->oprofile_cpu_type;
	ops->create_files = op_powerpc_create_files;
	ops->setup = op_powerpc_setup;
	ops->shutdown = op_powerpc_shutdown;
	ops->start = op_powerpc_start;
	ops->stop = op_powerpc_stop;
	ops->backtrace = op_powerpc_backtrace;

	printk(KERN_DEBUG "oprofile: using %s performance monitoring.\n",
	       ops->cpu_type);

	return 0;
}

void oprofile_arch_exit(void)
{
}
Commit	Line	Data
1da177e4	1	/*
86a5cddb	2	* PPC 64 oprofile support:
1da177e4	3	* Copyright (C) 2004 Anton Blanchard <anton@au.ibm.com>, IBM
86a5cddb SR	4	* PPC 32 oprofile support: (based on PPC 64 support)
	5	* Copyright (C) Freescale Semiconductor, Inc 2004
	6	* Author: Andy Fleming
1da177e4 LT	7	*
	8	* Based on alpha version.
	9	*
	10	* This program is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU General Public License
	12	* as published by the Free Software Foundation; either version
	13	* 2 of the License, or (at your option) any later version.
	14	*/
	15
	16	#include <linux/oprofile.h>
	17	#include <linux/init.h>
	18	#include <linux/smp.h>
	19	#include <linux/errno.h>
	20	#include <asm/ptrace.h>
	21	#include <asm/system.h>
	22	#include <asm/pmc.h>
a6908cd0	23	#include <asm/cputable.h>
dca85932	24	#include <asm/oprofile_impl.h>
2191fe3e	25	#include <asm/firmware.h>
1da177e4	26
a3e48c10	27	static struct op_powerpc_model *model;
1da177e4 LT	28
	29	static struct op_counter_config ctr[OP_MAX_COUNTER];
	30	static struct op_system_config sys;
	31
1474855d BN	32	static int op_per_cpu_rc;
1474855d BN	33
1da177e4 LT	34	static void op_handle_interrupt(struct pt_regs *regs)
	35	{
	36	model->handle_interrupt(regs, ctr);
	37	}
	38
dd6c89f6 AF	39	static void op_powerpc_cpu_setup(void *dummy)
dd6c89f6 AF	40	{
1474855d BN	41	int ret;
	42
	43	ret = model->cpu_setup(ctr);
	44
	45	if (ret != 0)
	46	op_per_cpu_rc = ret;
dd6c89f6 AF	47	}
dd6c89f6 AF	48
86a5cddb	49	static int op_powerpc_setup(void)
1da177e4 LT	50	{
	51	int err;
	52
1474855d BN	53	op_per_cpu_rc = 0;
1474855d BN	54
1da177e4 LT	55	/* Grab the hardware */
	56	err = reserve_pmc_hardware(op_handle_interrupt);
	57	if (err)
	58	return err;
	59
	60	/* Pre-compute the values to stuff in the hardware registers. */
1474855d	61	op_per_cpu_rc = model->reg_setup(ctr, &sys, model->num_counters);
1da177e4	62
1474855d BN	63	if (op_per_cpu_rc)
	64	goto out;
	65
	66	/* Configure the registers on all cpus. If an error occurs on one
	67	* of the cpus, op_per_cpu_rc will be set to the error */
15c8b6c1	68	on_each_cpu(op_powerpc_cpu_setup, NULL, 1);
1da177e4	69
1474855d BN	70	out: if (op_per_cpu_rc) {
	71	/* error on setup release the performance counter hardware */
	72	release_pmc_hardware();
	73	}
	74
	75	return op_per_cpu_rc;
1da177e4 LT	76	}
1da177e4 LT	77
86a5cddb	78	static void op_powerpc_shutdown(void)
1da177e4 LT	79	{
	80	release_pmc_hardware();
	81	}
	82
86a5cddb	83	static void op_powerpc_cpu_start(void *dummy)
1da177e4	84	{
1474855d BN	85	/* If any of the cpus have return an error, set the
	86	* global flag to the error so it can be returned
	87	* to the generic OProfile caller.
	88	*/
	89	int ret;
	90
	91	ret = model->start(ctr);
	92	if (ret != 0)
	93	op_per_cpu_rc = ret;
1da177e4 LT	94	}
1da177e4 LT	95
86a5cddb	96	static int op_powerpc_start(void)
1da177e4	97	{
1474855d BN	98	op_per_cpu_rc = 0;
1474855d BN	99
18f2190d	100	if (model->global_start)
1474855d BN	101	return model->global_start(ctr);
1474855d BN	102	if (model->start) {
15c8b6c1	103	on_each_cpu(op_powerpc_cpu_start, NULL, 1);
1474855d BN	104	return op_per_cpu_rc;
	105	}
	106	return -EIO; /* No start function is defined for this
	107	power architecture */
1da177e4 LT	108	}
1da177e4 LT	109
86a5cddb	110	static inline void op_powerpc_cpu_stop(void *dummy)
1da177e4 LT	111	{
	112	model->stop();
	113	}
	114
86a5cddb	115	static void op_powerpc_stop(void)
1da177e4	116	{
18f2190d	117	if (model->stop)
15c8b6c1	118	on_each_cpu(op_powerpc_cpu_stop, NULL, 1);
18f2190d MJ	119	if (model->global_stop)
18f2190d MJ	120	model->global_stop();
1da177e4 LT	121	}
1da177e4 LT	122
86a5cddb	123	static int op_powerpc_create_files(struct super_block sb, struct dentry root)
1da177e4 LT	124	{
	125	int i;
	126
555d97ac	127	#ifdef CONFIG_PPC64
1da177e4 LT	128	/*
	129	* There is one mmcr0, mmcr1 and mmcra for setting the events for
	130	* all of the counters.
	131	*/
	132	oprofilefs_create_ulong(sb, root, "mmcr0", &sys.mmcr0);
	133	oprofilefs_create_ulong(sb, root, "mmcr1", &sys.mmcr1);
	134	oprofilefs_create_ulong(sb, root, "mmcra", &sys.mmcra);
88382329 CL	135	#ifdef CONFIG_OPROFILE_CELL
	136	/* create a file the user tool can check to see what level of profiling
	137	* support exits with this kernel. Initialize bit mask to indicate
	138	* what support the kernel has:
	139	* bit 0 - Supports SPU event profiling in addition to PPU
	140	* event and cycles; and SPU cycle profiling
	141	* bits 1-31 - Currently unused.
	142	*
	143	* If the file does not exist, then the kernel only supports SPU
	144	* cycle profiling, PPU event and cycle profiling.
	145	*/
	146	oprofilefs_create_ulong(sb, root, "cell_support", &sys.cell_support);
	147	sys.cell_support = 0x1; /* Note, the user OProfile tool must check
	148	* that this bit is set before attempting to
	149	* user SPU event profiling. Older kernels
	150	* will not have this file, hence the user
	151	* tool is not allowed to do SPU event
	152	* profiling on older kernels. Older kernels
	153	* will accept SPU events but collected data
	154	* is garbage.
	155	*/
	156	#endif
555d97ac	157	#endif
1da177e4 LT	158
	159	for (i = 0; i < model->num_counters; ++i) {
	160	struct dentry *dir;
0c6856f7	161	char buf[4];
1da177e4 LT	162
	163	snprintf(buf, sizeof buf, "%d", i);
	164	dir = oprofilefs_mkdir(sb, root, buf);
	165
	166	oprofilefs_create_ulong(sb, dir, "enabled", &ctr[i].enabled);
	167	oprofilefs_create_ulong(sb, dir, "event", &ctr[i].event);
	168	oprofilefs_create_ulong(sb, dir, "count", &ctr[i].count);
555d97ac	169
1da177e4	170	/*
555d97ac AF	171	* Classic PowerPC doesn't support per-counter
	172	* control like this, but the options are
	173	* expected, so they remain. For Freescale
	174	* Book-E style performance monitors, we do
	175	* support them.
1da177e4 LT	176	*/
	177	oprofilefs_create_ulong(sb, dir, "kernel", &ctr[i].kernel);
	178	oprofilefs_create_ulong(sb, dir, "user", &ctr[i].user);
86a5cddb	179
1da177e4 LT	180	oprofilefs_create_ulong(sb, dir, "unit_mask", &ctr[i].unit_mask);
	181	}
	182
	183	oprofilefs_create_ulong(sb, root, "enable_kernel", &sys.enable_kernel);
	184	oprofilefs_create_ulong(sb, root, "enable_user", &sys.enable_user);
1da177e4 LT	185
	186	/* Default to tracing both kernel and user */
	187	sys.enable_kernel = 1;
	188	sys.enable_user = 1;
1da177e4 LT	189
	190	return 0;
	191	}
	192
	193	int __init oprofile_arch_init(struct oprofile_operations *ops)
	194	{
32a33994	195	if (!cur_cpu_spec->oprofile_cpu_type)
8fef0306	196	return -ENODEV;
32a33994	197
2191fe3e KD	198	if (firmware_has_feature(FW_FEATURE_ISERIES))
	199	return -ENODEV;
	200
32a33994	201	switch (cur_cpu_spec->oprofile_type) {
1caca371	202	#ifdef CONFIG_PPC_BOOK3S_64
1474855d	203	#ifdef CONFIG_OPROFILE_CELL
18f2190d	204	case PPC_OPROFILE_CELL:
ef66f796 IK	205	if (firmware_has_feature(FW_FEATURE_LPAR))
ef66f796 IK	206	return -ENODEV;
18f2190d	207	model = &op_model_cell;
1474855d BN	208	ops->sync_start = model->sync_start;
1474855d BN	209	ops->sync_stop = model->sync_stop;
18f2190d MJ	210	break;
18f2190d MJ	211	#endif
7a45fb19	212	case PPC_OPROFILE_RS64:
32a33994 AB	213	model = &op_model_rs64;
32a33994 AB	214	break;
7a45fb19	215	case PPC_OPROFILE_POWER4:
32a33994 AB	216	model = &op_model_power4;
32a33994 AB	217	break;
25fc530e OJ	218	case PPC_OPROFILE_PA6T:
	219	model = &op_model_pa6t;
	220	break;
dd6c89f6 AF	221	#endif
dd6c89f6 AF	222	#ifdef CONFIG_6xx
7a45fb19	223	case PPC_OPROFILE_G4:
32a33994 AB	224	model = &op_model_7450;
	225	break;
	226	#endif
39aef685 AF	227	#if defined(CONFIG_FSL_EMB_PERFMON)
	228	case PPC_OPROFILE_FSL_EMB:
	229	model = &op_model_fsl_emb;
32a33994 AB	230	break;
	231	#endif
	232	default:
	233	return -ENODEV;
	234	}
	235
a6908cd0	236	model->num_counters = cur_cpu_spec->num_pmcs;
8fef0306 AB	237
8fef0306 AB	238	ops->cpu_type = cur_cpu_spec->oprofile_cpu_type;
86a5cddb SR	239	ops->create_files = op_powerpc_create_files;
	240	ops->setup = op_powerpc_setup;
	241	ops->shutdown = op_powerpc_shutdown;
	242	ops->start = op_powerpc_start;
	243	ops->stop = op_powerpc_stop;
6c6bd754	244	ops->backtrace = op_powerpc_backtrace;
1da177e4	245
5e1415c3	246	printk(KERN_DEBUG "oprofile: using %s performance monitoring.\n",
1da177e4 LT	247	ops->cpu_type);
	248
	249	return 0;
	250	}
	251
	252	void oprofile_arch_exit(void)
	253	{
	254	}