[Feature]add MT2731_MP2_MR2_SVN388 baseline version
Change-Id: Ief04314834b31e27effab435d3ca8ba33b499059
diff --git a/src/devtools/met-driver/met_api/met_api.c b/src/devtools/met-driver/met_api/met_api.c
new file mode 100644
index 0000000..8e4ca5e
--- /dev/null
+++ b/src/devtools/met-driver/met_api/met_api.c
@@ -0,0 +1,398 @@
+/*
+ * 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);