src/devtools/met-driver/met_api/met_api.c

/*
 * Copyright (C) 2017 MediaTek Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See http://www.gnu.org/licenses/gpl-2.0.html for more details.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/tracepoint.h>
#include <trace/events/sched.h>
#include <trace/events/power.h>
#include <linux/dma-mapping.h>

#include <linux/kallsyms.h>
#include <linux/printk.h>
#include <linux/perf_event.h>
#include <linux/kthread.h>
#include <asm/arch_timer.h>
#include <asm/cpu.h>
#include <linux/smp.h> /* arch_send_call_function_single_ipi */

/******************************************************************************
 * Tracepoints
 ******************************************************************************/
#define MET_DEFINE_PROBE(probe_name, proto) \
		static void probe_##probe_name(void *data, PARAMS(proto))
#define MET_REGISTER_TRACE(probe_name) \
		register_trace_##probe_name(probe_##probe_name, NULL)
#define MET_UNREGISTER_TRACE(probe_name) \
		unregister_trace_##probe_name(probe_##probe_name, NULL)

struct met_api_tbl {
	int (*met_tag_start)(unsigned int class_id,
			     const char *name);
	int (*met_tag_end)(unsigned int class_id,
			   const char *name);
	int (*met_tag_async_start)(unsigned int class_id,
				   const char *name,
				   unsigned int cookie);
	int (*met_tag_async_end)(unsigned int class_id,
				 const char *name,
				 unsigned int cookie);
	int (*met_tag_oneshot)(unsigned int class_id,
			       const char *name,
			       unsigned int value);
	int (*met_tag_userdata)(char *pData);
	int (*met_tag_dump)(unsigned int class_id,
			    const char *name,
			    void *data,
			    unsigned int length);
	int (*met_tag_disable)(unsigned int class_id);
	int (*met_tag_enable)(unsigned int class_id);
	int (*met_set_dump_buffer)(int size);
	int (*met_save_dump_buffer)(const char *pathname);
	int (*met_save_log)(const char *pathname);
	int (*met_show_bw_limiter)(void);
	int (*met_reg_bw_limiter)(void *fp);
	int (*met_show_clk_tree)(const char *name,
				 unsigned int addr,
				 unsigned int status);
	int (*met_reg_clk_tree)(void *fp);
	void (*met_sched_switch)(struct task_struct *prev,
				 struct task_struct *next);
	int (*enable_met_backlight_tag)(void);
	int (*output_met_backlight_tag)(int level);
};

struct met_api_tbl met_ext_api;
EXPORT_SYMBOL(met_ext_api);

#if 0
int met_tag_init(void)
{
	return 0;
}
EXPORT_SYMBOL(met_tag_init);

int met_tag_uninit(void)
{
	return 0;
}
EXPORT_SYMBOL(met_tag_uninit);
#endif

int met_tag_start(unsigned int class_id, const char *name)
{
	if (met_ext_api.met_tag_start)
		return met_ext_api.met_tag_start(class_id, name);
	return 0;
}
EXPORT_SYMBOL(met_tag_start);

int met_tag_end(unsigned int class_id, const char *name)
{
	if (met_ext_api.met_tag_end)
		return met_ext_api.met_tag_end(class_id, name);
	return 0;
}
EXPORT_SYMBOL(met_tag_end);

int met_tag_async_start(unsigned int class_id,
			const char *name,
			unsigned int cookie)
{
	if (met_ext_api.met_tag_async_start)
		return met_ext_api.met_tag_async_start(class_id, name, cookie);
	return 0;
}
EXPORT_SYMBOL(met_tag_async_start);

int met_tag_async_end(unsigned int class_id,
		      const char *name,
		      unsigned int cookie)
{
	if (met_ext_api.met_tag_async_end)
		return met_ext_api.met_tag_async_end(class_id, name, cookie);
	return 0;
}
EXPORT_SYMBOL(met_tag_async_end);

int met_tag_oneshot(unsigned int class_id, const char *name, unsigned int value)
{
	if (met_ext_api.met_tag_oneshot)
		return met_ext_api.met_tag_oneshot(class_id, name, value);
	return 0;
}
EXPORT_SYMBOL(met_tag_oneshot);

int met_tag_userdata(char *pData)
{
	if (met_ext_api.met_tag_userdata)
		return met_ext_api.met_tag_userdata(pData);
	return 0;
}
EXPORT_SYMBOL(met_tag_userdata);

int met_tag_dump(unsigned int class_id,
		 const char *name,
		 void *data,
		 unsigned int length)
{
	if (met_ext_api.met_tag_dump)
		return met_ext_api.met_tag_dump(class_id, name, data, length);
	return 0;
}
EXPORT_SYMBOL(met_tag_dump);

int met_tag_disable(unsigned int class_id)
{
	if (met_ext_api.met_tag_disable)
		return met_ext_api.met_tag_disable(class_id);
	return 0;
}
EXPORT_SYMBOL(met_tag_disable);

int met_tag_enable(unsigned int class_id)
{
	if (met_ext_api.met_tag_enable)
		return met_ext_api.met_tag_enable(class_id);
	return 0;
}
EXPORT_SYMBOL(met_tag_enable);

int met_set_dump_buffer(int size)
{
	if (met_ext_api.met_set_dump_buffer)
		return met_ext_api.met_set_dump_buffer(size);
	return 0;
}
EXPORT_SYMBOL(met_set_dump_buffer);

int met_save_dump_buffer(const char *pathname)
{
	if (met_ext_api.met_save_dump_buffer)
		return met_ext_api.met_save_dump_buffer(pathname);
	return 0;
}
EXPORT_SYMBOL(met_save_dump_buffer);

int met_save_log(const char *pathname)
{
	if (met_ext_api.met_save_log)
		return met_ext_api.met_save_log(pathname);
	return 0;
}
EXPORT_SYMBOL(met_save_log);

int met_show_bw_limiter(void)
{
	if (met_ext_api.met_show_bw_limiter)
		return met_ext_api.met_show_bw_limiter();
	return 0;
}
EXPORT_SYMBOL(met_show_bw_limiter);

int met_reg_bw_limiter(void *fp)
{
	if (met_ext_api.met_reg_bw_limiter)
		return met_ext_api.met_reg_bw_limiter(fp);
	return 0;
}
EXPORT_SYMBOL(met_reg_bw_limiter);

int met_show_clk_tree(const char *name,
				unsigned int addr,
				unsigned int status)
{
	if (met_ext_api.met_show_clk_tree)
		return met_ext_api.met_show_clk_tree(name, addr, status);
	return 0;
}
EXPORT_SYMBOL(met_show_clk_tree);

int met_reg_clk_tree(void *fp)
{
	if (met_ext_api.met_reg_clk_tree)
		return met_ext_api.met_reg_clk_tree(fp);
	return 0;
}
EXPORT_SYMBOL(met_reg_clk_tree);

MET_DEFINE_PROBE(sched_switch,
		 TP_PROTO(bool preempt,
			  struct task_struct *prev,
			  struct task_struct *next))
{
	if (met_ext_api.met_sched_switch)
		met_ext_api.met_sched_switch(prev, next);
}

int met_reg_switch(void)
{
	if (MET_REGISTER_TRACE(sched_switch)) {
		pr_debug("can not register callback of sched_switch\n");
		return -ENODEV;
	} else
		return 0;
}
EXPORT_SYMBOL(met_reg_switch);

void met_unreg_switch(void)
{
	MET_UNREGISTER_TRACE(sched_switch);
}
EXPORT_SYMBOL(met_unreg_switch);

#if	defined(CONFIG_MET_ARM_32BIT)
void met_get_cpuinfo(int cpu, struct cpuinfo_arm **cpuinfo)
{
	*cpuinfo = &per_cpu(cpu_data, cpu);
}
#else
void met_get_cpuinfo(int cpu, struct cpuinfo_arm64 **cpuinfo)
{
	*cpuinfo = &per_cpu(cpu_data, cpu);
}
#endif
EXPORT_SYMBOL(met_get_cpuinfo);

void met_cpu_frequency(unsigned int frequency, unsigned int cpu_id)
{
	trace_cpu_frequency(frequency, cpu_id);
}
EXPORT_SYMBOL(met_cpu_frequency);

void met_tracing_record_cmdline(struct task_struct *tsk)
{
	tracing_record_cmdline(tsk);
}
EXPORT_SYMBOL(met_tracing_record_cmdline);

void met_set_kptr_restrict(int value)
{
	kptr_restrict = value;
}
EXPORT_SYMBOL(met_set_kptr_restrict);

int met_get_kptr_restrict(void)
{
	return kptr_restrict;
}
EXPORT_SYMBOL(met_get_kptr_restrict);

void met_arch_setup_dma_ops(struct device *dev)
{
	arch_setup_dma_ops(dev, 0, 0, NULL, false);
}
EXPORT_SYMBOL(met_arch_setup_dma_ops);

#if 1
int enable_met_backlight_tag(void)
{
	if (met_ext_api.enable_met_backlight_tag)
		return met_ext_api.enable_met_backlight_tag();
	return 0;
}
EXPORT_SYMBOL(enable_met_backlight_tag);

int output_met_backlight_tag(int level)
{
	if (met_ext_api.output_met_backlight_tag)
		return met_ext_api.output_met_backlight_tag(level);
	return 0;
}
EXPORT_SYMBOL(output_met_backlight_tag);
#endif

/* the following handle weak function in met_drv.h */
void met_mmsys_event_gce_thread_begin(ulong thread_no, ulong task_handle,
				ulong engineFlag, void *pCmd, ulong size)
{
}
EXPORT_SYMBOL(met_mmsys_event_gce_thread_begin);

void met_mmsys_event_gce_thread_end(ulong thread_no,
				    ulong task_handle,
				    ulong engineFlag)
{
}
EXPORT_SYMBOL(met_mmsys_event_gce_thread_end);

void met_mmsys_event_disp_sof(int mutex_id)
{
}
EXPORT_SYMBOL(met_mmsys_event_disp_sof);

void met_mmsys_event_disp_mutex_eof(int mutex_id)
{
}
EXPORT_SYMBOL(met_mmsys_event_disp_mutex_eof);

void met_mmsys_event_disp_ovl_eof(int ovl_id)
{
}
EXPORT_SYMBOL(met_mmsys_event_disp_ovl_eof);

void met_mmsys_config_isp_base_addr(unsigned long *isp_reg_list)
{
}
EXPORT_SYMBOL(met_mmsys_config_isp_base_addr);

void met_mmsys_event_isp_pass1_begin(int sensor_id)
{
}
EXPORT_SYMBOL(met_mmsys_event_isp_pass1_begin);

void met_mmsys_event_isp_pass1_end(int sensor_id)
{
}
EXPORT_SYMBOL(met_mmsys_event_isp_pass1_end);

void met_show_pmic_info(unsigned int RegNum, unsigned int pmic_reg)
{
}
EXPORT_SYMBOL(met_show_pmic_info);

u64 met_perf_event_read_local(struct perf_event *ev)
{
	return perf_event_read_local(ev);
}
EXPORT_SYMBOL(met_perf_event_read_local);

struct task_struct *met_kthread_create_on_cpu(int (*threadfn)(void *data),
				void *data, unsigned int cpu,
				const char *namefmt)
{
	return kthread_create_on_cpu(threadfn, data, cpu, namefmt);
}
EXPORT_SYMBOL(met_kthread_create_on_cpu);

int met_smp_call_function_single(
	int cpu,
	smp_call_func_t func,
	void *info,
	int wait)
{
	return smp_call_function_single(cpu, func, info, wait);
}
EXPORT_SYMBOL(met_smp_call_function_single);

u64 met_arch_counter_get_cntvct(void)
{
	return arch_counter_get_cntvct();
}
EXPORT_SYMBOL(met_arch_counter_get_cntvct);

void met_arch_send_call_function_single_ipi(int cpu)
{
	return arch_send_call_function_single_ipi(cpu);
}
EXPORT_SYMBOL(met_arch_send_call_function_single_ipi);