src/devtools/met-driver/4.14/common/met_main.c - T103 - Gitiles

 /*
  * Copyright (C) 2018 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 the
  * GNU General Public License for more details.
  */

 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/hrtimer.h>
 #include <linux/cpu.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/profile.h>
 #include <linux/dcache.h>
 #include <linux/types.h>
 #include <linux/dcookies.h>
 #include <linux/sched.h>
 #include <linux/fs.h>

 #include <asm/irq_regs.h>

 #include "met_struct.h"
 #include "met_drv.h"
 #include "met_kernel_symbol.h"
 #include "interface.h"
 #include <linux/of.h>


 extern struct device_node *of_root;
 static const char *platform_name;

 struct cpu_type_name {
 	char full_name[32];
 	char abbr_name[8];
 };

 static struct cpu_type_name met_known_cpu_type[] = {
 	{"arm,cortex-a53", "CA53"},
 	{"arm,cortex-a55", "CA55"},
 	{"arm,cortex-a73", "CA73"},
 	{"arm,cortex-a75", "CA75"},
 };
 #define MET_KNOWN_CPU_TYPE_COUNT \
 	(sizeof(met_known_cpu_type)/sizeof(struct cpu_type_name))

 static char met_cpu_topology[64];

 #if	defined(CONFIG_MET_ARM_32BIT)
 void (*met_get_cpuinfo_symbol)(int cpu, struct cpuinfo_arm **cpuinfo);
 #else
 void (*met_get_cpuinfo_symbol)(int cpu, struct cpuinfo_arm64 **cpuinfo);
 #endif

 void (*tracing_record_cmdline_symbol)(struct task_struct *tsk);
 void (*met_cpu_frequency_symbol)(unsigned int frequency, unsigned int cpu_id);
 int (*met_reg_switch_symbol)(void);
 void (*met_unreg_switch_symbol)(void);

 #ifdef MET_EVENT_POWER_SUPPORT
 int (*met_reg_event_power_symbol)(void);
 void (*met_unreg_event_power_symbol)(void);
 #endif

 void (*met_arch_setup_dma_ops_symbol)(struct device *dev);
 int (*met_perf_event_read_local_symbol)(struct perf_event *ev, u64 *value);
 struct task_struct *(*met_kthread_create_on_cpu_symbol)(int (*threadfn)(void *data),
 				void *data, unsigned int cpu,
 				const char *namefmt);
 int (*met_smp_call_function_single_symbol)(int cpu, smp_call_func_t func, void *info, int wait);

 #ifdef MTK_PLATFORM
 #define _SHOW_MTK_PLATFORM(X) #X
 #define SHOW_MTK_PLATFORM(X) _SHOW_MTK_PLATFORM(X)
 #endif

 static int is_platform_name_valid(const char * buf)
 {
 	int len = strlen(buf);
 	int i;

 	for (i=0; i<len; i++) {
 		if ((buf[i] == 'm' && buf[i+1] == 't')
 			|| (buf[i] == 'M' && buf[i+1] == 'T')
 			|| (buf[i] == 'M' && buf[i+1] == 't')
 			|| (buf[i] == 'm' && buf[i+1] == 'T')) {
 			return 1;
 		}
 	}
 	return 0;
 }

 const char *met_get_platform_name(void)
 {
 	const char default_platform_name[7] = "mtxxxx";
 	int found = 0;

 	found = is_platform_name_valid(platform_name);

 	if(found == 0){
 #ifdef MTK_PLATFORM
 		const char buf[7] = SHOW_MTK_PLATFORM(MTK_PLATFORM);
 		found = is_platform_name_valid(buf);
 		if(found == 1)
 			platform_name = buf;
 		else
 #endif
 			platform_name = default_platform_name;
 	}
 	return platform_name;
 }
 EXPORT_SYMBOL(met_get_platform_name);

 static void get_cpu_type_name(const char *compatible, char *cpu_type)
 {
 	int i;

 	for (i = 0; i < MET_KNOWN_CPU_TYPE_COUNT; i++) {
 		if (!strncmp(compatible, met_known_cpu_type[i].full_name,strlen(met_known_cpu_type[i].full_name)))
 			strscpy(cpu_type, met_known_cpu_type[i].abbr_name,sizeof(cpu_type));
 	}
 }

 static void met_set_cpu_topology(int core_id, int cluster_core_num)
 {
 	int i, buf_len = strlen(met_cpu_topology);
 	struct device_node *node = NULL;
 	const char *prev_cptb = NULL;
 	const char *cptb;
 	char cpu_type[16];

 	for (i = 0; i < cluster_core_num; i++) {
 		node = of_get_cpu_node(core_id + i, NULL);
 		if (node) {
 			cptb = of_get_property(node, "compatible", NULL);
 			if (cptb) {
 				get_cpu_type_name(cptb, cpu_type);
 				if (prev_cptb == NULL)
 					/* first write:  write core_type & core_number */
 					buf_len += snprintf(met_cpu_topology + buf_len,
 								sizeof(met_cpu_topology) - buf_len,
 								"%s:%d", cpu_type, core_id + i);
 				else if (!strncmp(prev_cptb, cptb, strlen(prev_cptb)))
 					/* cpu type is the same with before */
 					/* write core_number */
 					buf_len += snprintf(met_cpu_topology + buf_len,
 								sizeof(met_cpu_topology) - buf_len,
 								",%d", core_id + i);
 				else
 					/* cpu type is different with before */
 					/* write core_type & core_number */
 					buf_len += snprintf(met_cpu_topology + buf_len,
 								sizeof(met_cpu_topology) - buf_len,
 								"|%s:%d", cpu_type, core_id + i);

 				prev_cptb = cptb;
 			}
 		}
 	}
 }

 static int met_create_cpu_topology(void)
 {
 	int i, j, len;
 	struct device_node *node = NULL, *core_node = NULL;
 	int start_core_id = 0;
 	int cluster_num = 0, cluster_core_num = 0;
 	char cluster_name[16], core_name[16];

 	node = of_find_node_by_name(NULL, "cpu-map");
 	if (!node)
 		node = of_find_node_by_name(NULL, "virtual-cpu-map");

 	if (node) {
 		cluster_num = of_get_child_count(node);
 		of_node_put(node);

 		for (i = 0; i < cluster_num; i++) {
 			snprintf(cluster_name, sizeof(cluster_name), "cluster%d", i);
 			node = of_find_node_by_name(NULL, cluster_name);
 			if (node) {

 				j = 0;
 				cluster_core_num = 0;
 				do {
 					snprintf(core_name, sizeof(core_name), "core%d", j);
 					core_node = of_get_child_by_name(node, core_name);
 					if (core_node) {
 						cluster_core_num++;
 						of_node_put(core_node);
 					}
 					j++;
 				} while (core_node);
 				of_node_put(node);

 				/* "|" use to separate different cluster */
 				if (i > 0) {
 					len = strlen(met_cpu_topology);
 					snprintf(met_cpu_topology + len, sizeof(met_cpu_topology) - len, "|");
 				}

 				met_set_cpu_topology(start_core_id, cluster_core_num);
 				start_core_id = cluster_core_num;
 			}
 		}
 	}

 	return strlen(met_cpu_topology);
 }

 static int met_kernel_symbol_get(void)
 {
 	int ret = 0;

 	if (met_get_cpuinfo_symbol == NULL)
 		met_get_cpuinfo_symbol = (void *)symbol_get(met_get_cpuinfo);
 	if (met_get_cpuinfo_symbol == NULL)
 		return -2;

 	if (tracing_record_cmdline_symbol == NULL)
 		tracing_record_cmdline_symbol = (void *)symbol_get(met_tracing_record_cmdline);
 	if (tracing_record_cmdline_symbol == NULL)
 		ret = -3;

 	if (met_cpu_frequency_symbol == NULL)
 		met_cpu_frequency_symbol = (void *)symbol_get(met_cpu_frequency);
 	if (met_cpu_frequency_symbol == NULL)
 		ret = -4;

 	if (met_reg_switch_symbol == NULL)
 		met_reg_switch_symbol = (void *)symbol_get(met_reg_switch);
 	if (met_reg_switch_symbol == NULL)
 		ret = -5;

 	if (met_unreg_switch_symbol == NULL)
 		met_unreg_switch_symbol = (void *)symbol_get(met_unreg_switch);
 	if (met_unreg_switch_symbol == NULL)
 		ret = -6;

 	if (met_arch_setup_dma_ops_symbol == NULL)
 		met_arch_setup_dma_ops_symbol = (void *)symbol_get(met_arch_setup_dma_ops);
 	if (met_arch_setup_dma_ops_symbol == NULL)
 		ret = -7;

 	if (met_perf_event_read_local_symbol == NULL)
 		met_perf_event_read_local_symbol = (void *)symbol_get(met_perf_event_read_local);
 	if (met_perf_event_read_local_symbol == NULL)
 		ret = -8;

 	if (met_kthread_create_on_cpu_symbol == NULL)
 		met_kthread_create_on_cpu_symbol = (void *)symbol_get(met_kthread_create_on_cpu);
 	if (met_kthread_create_on_cpu_symbol == NULL)
 		ret = -9;

 	if (met_smp_call_function_single_symbol == NULL)
 		met_smp_call_function_single_symbol = (void *)symbol_get(met_smp_call_function_single);
 	if (met_smp_call_function_single_symbol == NULL)
 		ret = -10;

 #ifdef MET_EVENT_POWER_SUPPORT
 	if (met_reg_event_power_symbol == NULL)
 		met_reg_event_power_symbol = (void *)symbol_get(met_reg_event_power);
 	if (met_reg_event_power_symbol == NULL)
 		ret = -11;

 	if (met_unreg_event_power_symbol == NULL)
 		met_unreg_event_power_symbol = (void *)symbol_get(met_unreg_event_power);
 	if (met_unreg_event_power_symbol == NULL)
 		ret = -12;
 #endif

 	return ret;
 }

 DEFINE_PER_CPU(struct met_cpu_struct, met_cpu);

 static int __init met_drv_init(void)
 {
 	int cpu;
 	int ret;
 	int cpu_topology_len;
 	struct met_cpu_struct *met_cpu_ptr;

 	for_each_possible_cpu(cpu) {
 		met_cpu_ptr = &per_cpu(met_cpu, cpu);
 		/* snprintf(&(met_cpu_ptr->name[0]), sizeof(met_cpu_ptr->name), "met%02d", cpu); */
 		met_cpu_ptr->cpu = cpu;
 	}

 	ret = met_kernel_symbol_get();
 	if (ret) {
 		pr_notice("[MET] met_kernel_symbol_get fail, ret = %d\n", ret);
 		return ret;
 	}
 	fs_reg();

 	if (of_root){
 		/*
 			mt6765.dts
 			model = "MT6765";
 			compatible = "mediatek,MT6765";
 			interrupt-parent = <&sysirq>;
 		*/
 		if (of_root->properties) {
 			of_property_read_string(of_root, "compatible", &platform_name);
 			PR_BOOTMSG("dts property compatible=%s\n", platform_name);
 		}
 	}
 	if (platform_name) {
 		char buf[7];
 		int len = strlen(platform_name);
 		int i;
 		int found = 0;

 		for (i=0; i<len; i++) {
 			if ((platform_name[i] == 'm' && platform_name[i+1] == 't')
 				|| (platform_name[i] == 'M' && platform_name[i+1] == 'T')
 				|| (platform_name[i] == 'M' && platform_name[i+1] == 't')
 				|| (platform_name[i] == 'm' && platform_name[i+1] == 'T')) {
 				/* be sure to have 4 chars (chip id) behind 'mt' for copy */
 				if (len - i - 2 >= 4)
 					found = 1;
 				break;
 			}
 		}

 		if (found == 1) {
 			memset(buf, 0x0, 7);
 			buf[0] = 'm';
 			buf[1] = 't';
 			strncpy(&buf[2], &platform_name[i+2], 4);
 			met_set_platform(buf, 1);
 			PR_BOOTMSG("Get platform info from dts, platform_name=%s\n", buf);
 		} else {
 #ifdef MTK_PLATFORM
 			memset(buf, 0x0, 7);
 			strcpy(buf, SHOW_MTK_PLATFORM(MTK_PLATFORM));
 			found = is_platform_name_valid((const char *)buf);
 			if(found == 1){
 				PR_BOOTMSG("Get platform info from met_drv Kbuild, platform_name=%s\n", buf);
 				met_set_platform(buf, 1);
 			}
 			else
 #endif
 			{
 				PR_BOOTMSG("Can not get platform info from dts nor met_drv Kbuild, set platform_name=mtxxxx\n");
 				met_set_platform("mtxxxx", 1);
 			}
 		}
 	}

 	cpu_topology_len = met_create_cpu_topology();
 	if (cpu_topology_len)
 		met_set_topology(met_cpu_topology, 1);

 #ifdef MET_PLF_USE
 	core_plf_init();
 #endif
 	return 0;
 }

 static void __exit met_drv_exit(void)
 {
 	if (met_cpu_frequency_symbol)
 		symbol_put(met_cpu_frequency);
 	if (met_reg_switch_symbol)
 		symbol_put(met_reg_switch);
 	if (met_unreg_switch_symbol)
 		symbol_put(met_unreg_switch);

 #ifdef MET_EVENT_POWER_SUPPORT
 	if (met_reg_event_power_symbol)
 		symbol_put(met_reg_event_power);
 	if (met_unreg_event_power_symbol)
 		symbol_put(met_unreg_event_power);
 #endif

 	if (tracing_record_cmdline_symbol)
 		symbol_put(met_tracing_record_cmdline);
 	if (met_get_cpuinfo_symbol)
 		symbol_put(met_get_cpuinfo);

 #ifdef MET_PLF_USE
 	core_plf_exit();
 #endif
 	fs_unreg();

 }
 module_init(met_drv_init);
 module_exit(met_drv_exit);

 MODULE_AUTHOR("DT_DM5");
 MODULE_DESCRIPTION("MET_CORE");
 MODULE_LICENSE("GPL");
	/*
	* Copyright (C) 2018 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 the
	* GNU General Public License for more details.
	*/

	#include <linux/init.h>
	#include <linux/module.h>
	#include <linux/hrtimer.h>
	#include <linux/cpu.h>
	#include <linux/mm.h>
	#include <linux/slab.h>
	#include <linux/profile.h>
	#include <linux/dcache.h>
	#include <linux/types.h>
	#include <linux/dcookies.h>
	#include <linux/sched.h>
	#include <linux/fs.h>

	#include <asm/irq_regs.h>

	#include "met_struct.h"
	#include "met_drv.h"
	#include "met_kernel_symbol.h"
	#include "interface.h"
	#include <linux/of.h>


	extern struct device_node *of_root;
	static const char *platform_name;

	struct cpu_type_name {
	char full_name[32];
	char abbr_name[8];
	};

	static struct cpu_type_name met_known_cpu_type[] = {
	{"arm,cortex-a53", "CA53"},
	{"arm,cortex-a55", "CA55"},
	{"arm,cortex-a73", "CA73"},
	{"arm,cortex-a75", "CA75"},
	};
	#define MET_KNOWN_CPU_TYPE_COUNT \
	(sizeof(met_known_cpu_type)/sizeof(struct cpu_type_name))

	static char met_cpu_topology[64];

	#if defined(CONFIG_MET_ARM_32BIT)
	void (met_get_cpuinfo_symbol)(int cpu, struct cpuinfo_arm *cpuinfo);
	#else
	void (met_get_cpuinfo_symbol)(int cpu, struct cpuinfo_arm64 *cpuinfo);
	#endif

	void (tracing_record_cmdline_symbol)(struct task_struct tsk);
	void (*met_cpu_frequency_symbol)(unsigned int frequency, unsigned int cpu_id);
	int (*met_reg_switch_symbol)(void);
	void (*met_unreg_switch_symbol)(void);

	#ifdef MET_EVENT_POWER_SUPPORT
	int (*met_reg_event_power_symbol)(void);
	void (*met_unreg_event_power_symbol)(void);
	#endif

	void (met_arch_setup_dma_ops_symbol)(struct device dev);
	int (met_perf_event_read_local_symbol)(struct perf_event ev, u64 *value);
	struct task_struct (met_kthread_create_on_cpu_symbol)(int (threadfn)(void data),
	void *data, unsigned int cpu,
	const char *namefmt);
	int (met_smp_call_function_single_symbol)(int cpu, smp_call_func_t func, void info, int wait);

	#ifdef MTK_PLATFORM
	#define _SHOW_MTK_PLATFORM(X) #X
	#define SHOW_MTK_PLATFORM(X) _SHOW_MTK_PLATFORM(X)
	#endif

	static int is_platform_name_valid(const char * buf)
	{
	int len = strlen(buf);
	int i;

	for (i=0; i<len; i++) {
	if ((buf[i] == 'm' && buf[i+1] == 't')
	\|\| (buf[i] == 'M' && buf[i+1] == 'T')
	\|\| (buf[i] == 'M' && buf[i+1] == 't')
	\|\| (buf[i] == 'm' && buf[i+1] == 'T')) {
	return 1;
	}
	}
	return 0;
	}

	const char *met_get_platform_name(void)
	{
	const char default_platform_name[7] = "mtxxxx";
	int found = 0;

	found = is_platform_name_valid(platform_name);

	if(found == 0){
	#ifdef MTK_PLATFORM
	const char buf[7] = SHOW_MTK_PLATFORM(MTK_PLATFORM);
	found = is_platform_name_valid(buf);
	if(found == 1)
	platform_name = buf;
	else
	#endif
	platform_name = default_platform_name;
	}
	return platform_name;
	}
	EXPORT_SYMBOL(met_get_platform_name);

	static void get_cpu_type_name(const char compatible, char cpu_type)
	{
	int i;

	for (i = 0; i < MET_KNOWN_CPU_TYPE_COUNT; i++) {
	if (!strncmp(compatible, met_known_cpu_type[i].full_name,strlen(met_known_cpu_type[i].full_name)))
	strscpy(cpu_type, met_known_cpu_type[i].abbr_name,sizeof(cpu_type));
	}
	}

	static void met_set_cpu_topology(int core_id, int cluster_core_num)
	{
	int i, buf_len = strlen(met_cpu_topology);
	struct device_node *node = NULL;
	const char *prev_cptb = NULL;
	const char *cptb;
	char cpu_type[16];

	for (i = 0; i < cluster_core_num; i++) {
	node = of_get_cpu_node(core_id + i, NULL);
	if (node) {
	cptb = of_get_property(node, "compatible", NULL);
	if (cptb) {
	get_cpu_type_name(cptb, cpu_type);
	if (prev_cptb == NULL)
	/* first write: write core_type & core_number */
	buf_len += snprintf(met_cpu_topology + buf_len,
	sizeof(met_cpu_topology) - buf_len,
	"%s:%d", cpu_type, core_id + i);
	else if (!strncmp(prev_cptb, cptb, strlen(prev_cptb)))
	/* cpu type is the same with before */
	/* write core_number */
	buf_len += snprintf(met_cpu_topology + buf_len,
	sizeof(met_cpu_topology) - buf_len,
	",%d", core_id + i);
	else
	/* cpu type is different with before */
	/* write core_type & core_number */
	buf_len += snprintf(met_cpu_topology + buf_len,
	sizeof(met_cpu_topology) - buf_len,
	"\|%s:%d", cpu_type, core_id + i);

	prev_cptb = cptb;
	}
	}
	}
	}

	static int met_create_cpu_topology(void)
	{
	int i, j, len;
	struct device_node node = NULL, core_node = NULL;
	int start_core_id = 0;
	int cluster_num = 0, cluster_core_num = 0;
	char cluster_name[16], core_name[16];

	node = of_find_node_by_name(NULL, "cpu-map");
	if (!node)
	node = of_find_node_by_name(NULL, "virtual-cpu-map");

	if (node) {
	cluster_num = of_get_child_count(node);
	of_node_put(node);

	for (i = 0; i < cluster_num; i++) {
	snprintf(cluster_name, sizeof(cluster_name), "cluster%d", i);
	node = of_find_node_by_name(NULL, cluster_name);
	if (node) {

	j = 0;
	cluster_core_num = 0;
	do {
	snprintf(core_name, sizeof(core_name), "core%d", j);
	core_node = of_get_child_by_name(node, core_name);
	if (core_node) {
	cluster_core_num++;
	of_node_put(core_node);
	}
	j++;
	} while (core_node);
	of_node_put(node);

	/* "\|" use to separate different cluster */
	if (i > 0) {
	len = strlen(met_cpu_topology);
	snprintf(met_cpu_topology + len, sizeof(met_cpu_topology) - len, "\|");
	}

	met_set_cpu_topology(start_core_id, cluster_core_num);
	start_core_id = cluster_core_num;
	}
	}
	}

	return strlen(met_cpu_topology);
	}

	static int met_kernel_symbol_get(void)
	{
	int ret = 0;

	if (met_get_cpuinfo_symbol == NULL)
	met_get_cpuinfo_symbol = (void *)symbol_get(met_get_cpuinfo);
	if (met_get_cpuinfo_symbol == NULL)
	return -2;

	if (tracing_record_cmdline_symbol == NULL)
	tracing_record_cmdline_symbol = (void *)symbol_get(met_tracing_record_cmdline);
	if (tracing_record_cmdline_symbol == NULL)
	ret = -3;

	if (met_cpu_frequency_symbol == NULL)
	met_cpu_frequency_symbol = (void *)symbol_get(met_cpu_frequency);
	if (met_cpu_frequency_symbol == NULL)
	ret = -4;

	if (met_reg_switch_symbol == NULL)
	met_reg_switch_symbol = (void *)symbol_get(met_reg_switch);
	if (met_reg_switch_symbol == NULL)
	ret = -5;

	if (met_unreg_switch_symbol == NULL)
	met_unreg_switch_symbol = (void *)symbol_get(met_unreg_switch);
	if (met_unreg_switch_symbol == NULL)
	ret = -6;

	if (met_arch_setup_dma_ops_symbol == NULL)
	met_arch_setup_dma_ops_symbol = (void *)symbol_get(met_arch_setup_dma_ops);
	if (met_arch_setup_dma_ops_symbol == NULL)
	ret = -7;

	if (met_perf_event_read_local_symbol == NULL)
	met_perf_event_read_local_symbol = (void *)symbol_get(met_perf_event_read_local);
	if (met_perf_event_read_local_symbol == NULL)
	ret = -8;

	if (met_kthread_create_on_cpu_symbol == NULL)
	met_kthread_create_on_cpu_symbol = (void *)symbol_get(met_kthread_create_on_cpu);
	if (met_kthread_create_on_cpu_symbol == NULL)
	ret = -9;

	if (met_smp_call_function_single_symbol == NULL)
	met_smp_call_function_single_symbol = (void *)symbol_get(met_smp_call_function_single);
	if (met_smp_call_function_single_symbol == NULL)
	ret = -10;

	#ifdef MET_EVENT_POWER_SUPPORT
	if (met_reg_event_power_symbol == NULL)
	met_reg_event_power_symbol = (void *)symbol_get(met_reg_event_power);
	if (met_reg_event_power_symbol == NULL)
	ret = -11;

	if (met_unreg_event_power_symbol == NULL)
	met_unreg_event_power_symbol = (void *)symbol_get(met_unreg_event_power);
	if (met_unreg_event_power_symbol == NULL)
	ret = -12;
	#endif

	return ret;
	}

	DEFINE_PER_CPU(struct met_cpu_struct, met_cpu);

	static int __init met_drv_init(void)
	{
	int cpu;
	int ret;
	int cpu_topology_len;
	struct met_cpu_struct *met_cpu_ptr;

	for_each_possible_cpu(cpu) {
	met_cpu_ptr = &per_cpu(met_cpu, cpu);
	/* snprintf(&(met_cpu_ptr->name[0]), sizeof(met_cpu_ptr->name), "met%02d", cpu); */
	met_cpu_ptr->cpu = cpu;
	}

	ret = met_kernel_symbol_get();
	if (ret) {
	pr_notice("[MET] met_kernel_symbol_get fail, ret = %d\n", ret);
	return ret;
	}
	fs_reg();

	if (of_root){
	/*
	mt6765.dts
	model = "MT6765";
	compatible = "mediatek,MT6765";
	interrupt-parent = <&sysirq>;
	*/
	if (of_root->properties) {
	of_property_read_string(of_root, "compatible", &platform_name);
	PR_BOOTMSG("dts property compatible=%s\n", platform_name);
	}
	}
	if (platform_name) {
	char buf[7];
	int len = strlen(platform_name);
	int i;
	int found = 0;

	for (i=0; i<len; i++) {
	if ((platform_name[i] == 'm' && platform_name[i+1] == 't')
	\|\| (platform_name[i] == 'M' && platform_name[i+1] == 'T')
	\|\| (platform_name[i] == 'M' && platform_name[i+1] == 't')
	\|\| (platform_name[i] == 'm' && platform_name[i+1] == 'T')) {
	/* be sure to have 4 chars (chip id) behind 'mt' for copy */
	if (len - i - 2 >= 4)
	found = 1;
	break;
	}
	}

	if (found == 1) {
	memset(buf, 0x0, 7);
	buf[0] = 'm';
	buf[1] = 't';
	strncpy(&buf[2], &platform_name[i+2], 4);
	met_set_platform(buf, 1);
	PR_BOOTMSG("Get platform info from dts, platform_name=%s\n", buf);
	} else {
	#ifdef MTK_PLATFORM
	memset(buf, 0x0, 7);
	strcpy(buf, SHOW_MTK_PLATFORM(MTK_PLATFORM));
	found = is_platform_name_valid((const char *)buf);
	if(found == 1){
	PR_BOOTMSG("Get platform info from met_drv Kbuild, platform_name=%s\n", buf);
	met_set_platform(buf, 1);
	}
	else
	#endif
	{
	PR_BOOTMSG("Can not get platform info from dts nor met_drv Kbuild, set platform_name=mtxxxx\n");
	met_set_platform("mtxxxx", 1);
	}
	}
	}

	cpu_topology_len = met_create_cpu_topology();
	if (cpu_topology_len)
	met_set_topology(met_cpu_topology, 1);

	#ifdef MET_PLF_USE
	core_plf_init();
	#endif
	return 0;
	}

	static void __exit met_drv_exit(void)
	{
	if (met_cpu_frequency_symbol)
	symbol_put(met_cpu_frequency);
	if (met_reg_switch_symbol)
	symbol_put(met_reg_switch);
	if (met_unreg_switch_symbol)
	symbol_put(met_unreg_switch);

	#ifdef MET_EVENT_POWER_SUPPORT
	if (met_reg_event_power_symbol)
	symbol_put(met_reg_event_power);
	if (met_unreg_event_power_symbol)
	symbol_put(met_unreg_event_power);
	#endif

	if (tracing_record_cmdline_symbol)
	symbol_put(met_tracing_record_cmdline);
	if (met_get_cpuinfo_symbol)
	symbol_put(met_get_cpuinfo);

	#ifdef MET_PLF_USE
	core_plf_exit();
	#endif
	fs_unreg();

	}
	module_init(met_drv_init);
	module_exit(met_drv_exit);

	MODULE_AUTHOR("DT_DM5");
	MODULE_DESCRIPTION("MET_CORE");
	MODULE_LICENSE("GPL");