drivers/misc/mediatek/ssc/ssc_module.c - manifest_repos/kernel_device_modules-5.15 - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * Copyright (c) 2021 MediaTek Inc.
  */

 #include <linux/device.h>
 #include <linux/kernel.h>
 #include <linux/kobject.h>
 #include <linux/module.h>
 #include <linux/kobject.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>
 #include <linux/spinlock.h>
 #include <linux/suspend.h>
 #include <linux/atomic.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/consumer.h>
 #include <ssc_module.h>
 #include <mt-plat/ssc.h>

 //#define SSC_SYSFS_VLOGIC_BOUND_SUPPORT

 #if IS_ENABLED(CONFIG_MTK_AEE_FEATURE)
 #include <mt-plat/aee.h>
 #endif

 #if IS_ENABLED(CONFIG_ARM_SCMI_PROTOCOL)
 #include <linux/scmi_protocol.h>
 #include <tinysys-scmi.h>
 #endif

 #if IS_ENABLED(CONFIG_GPU_SUPPORT)
 #include <gpufreq_v2.h>
 static unsigned int gpueb_enable;
 #endif

 #if IS_ENABLED(CONFIG_MTK_AEE_FEATURE)
 #define ssc_aee_print(string, args...) do {\
 	char ssc_name[100];\
 	int ret;\
 	ret = snprintf(ssc_name, 100, "[SSC] "string, ##args); \
 	if (ret > 0)\
 		aee_kernel_exception_api(__FILE__, __LINE__, \
 		DB_OPT_MMPROFILE_BUFFER | DB_OPT_NE_JBT_TRACES, \
 		ssc_name, "[SSC] error:"string, ##args); \
 		pr_info("[SSC] error:"string, ##args);  \
 	} while (0)
 #else
 #define ssc_aee_print(string, args...) \
 	pr_info("[SSC] error:"string, ##args)
 #endif

 #define MTK_SSC_DTS_COMPATIBLE "mediatek,ssc"
 #define MTK_GPU_DTS_COMPATIBLE "mediatek,gpueb"
 #define SSC_VCORE_REGULATOR "dvfsrc-vcore"
 #define PLT_SSC_INIT     (0x504C5403) /*magic*/

 struct kobject *ssc_kobj;
 EXPORT_SYMBOL_GPL(ssc_kobj);

 unsigned int ssc_enable;
 EXPORT_SYMBOL_GPL(ssc_enable);

 static BLOCKING_NOTIFIER_HEAD(vlogic_bound_chain);
 static struct regulator *ssc_vcore_voter;

 static int set_vcore_vlogic_bound(en)
 {
 	int ret;

 	if (!ssc_vcore_voter) {
 		pr_info("[SSC] invalid vcore regulator\n");
 		return -1;
 	}

 	if (en)
 		ret = regulator_set_voltage(ssc_vcore_voter, 600000, INT_MAX);
 	else
 		ret = regulator_set_voltage(ssc_vcore_voter, 575000, INT_MAX);

 	if (ret) {
 		pr_info("[SSC] vcore vlogic bound %s fail\n", en ? "enable" : "disable");
 		return -1;
 	}

 	return 0;
 }


 static int set_gpu_vlogic_bound(int en)
 {

 	int ret = 0;

 #if IS_ENABLED(CONFIG_GPU_SUPPORT)
 	/* floor value for GPU = mV * 100 */
 	if (en)
 		ret = gpufreq_set_limit(TARGET_DEFAULT, LIMIT_SRAMRC,
 					GPUPPM_KEEP_IDX, 60000);
 	else
 		ret = gpufreq_set_limit(TARGET_DEFAULT, LIMIT_SRAMRC,
 					GPUPPM_KEEP_IDX, GPUPPM_RESET_IDX);

 	if (ret)
 		pr_info("[SSC] gpu vlogic bound %s fail\n", en ? "enable" : "disable");
 #endif
 	return ret;
 }

 static int ssc_vlogic_bound_event(struct notifier_block *notifier, unsigned long event,
 				void *data)
 {

 	unsigned int request_id = *((unsigned int *)data);

 	pr_info("[SSC] request ID = 0x%x, event = 0x%lx\n", request_id, event);

 	switch (event) {
 	case SSC_ENABLE_VLOGIC_BOUND:
 		set_gpu_vlogic_bound(1);
 		set_vcore_vlogic_bound(1);
 		return NOTIFY_DONE;
 	case SSC_DISABLE_VLOGIC_BOUND:
 		set_vcore_vlogic_bound(0);
 		set_gpu_vlogic_bound(0);
 		return NOTIFY_DONE;
 	case SSC_TIMEOUT:
 		return NOTIFY_DONE;
 	default:
 		return NOTIFY_BAD;
 	}
 	return NOTIFY_OK;
 }
 static struct notifier_block ssc_vlogic_notifier_func = {
 	.notifier_call = ssc_vlogic_bound_event,
 	.priority = 0,
 };

 static int ssc_vlogic_bound_call_chain(unsigned int val, unsigned int request_id)
 {
 	int ret;

 	ret = blocking_notifier_call_chain(&vlogic_bound_chain, val, &request_id);

 	if (ret == NOTIFY_DONE || ret == NOTIFY_OK)
 		return 0;
 	else
 		return -1;
 }
 static atomic_t vlogic_bound_counter;

 int ssc_vlogic_bound_register_notifier(struct notifier_block *nb)
 {
 	return blocking_notifier_chain_register(&vlogic_bound_chain, nb);
 }
 EXPORT_SYMBOL_GPL(ssc_vlogic_bound_register_notifier);

 int ssc_vlogic_bound_unregister_notifier(struct notifier_block *nb)
 {
 	return blocking_notifier_chain_unregister(&vlogic_bound_chain, nb);
 }
 EXPORT_SYMBOL_GPL(ssc_vlogic_bound_unregister_notifier);


 int ssc_enable_vlogic_bound(int request_id)
 {
 	/* check counter value */
 	if (atomic_read(&vlogic_bound_counter) < 0)
 		return -1;

 	/* check request_id */
 	if (request_id < 0 || request_id >= SSC_REQUEST_NUM)
 		return -1;

 	if (atomic_inc_return(&vlogic_bound_counter) == 1)
 		return ssc_vlogic_bound_call_chain(SSC_ENABLE_VLOGIC_BOUND, request_id);

 	/* vlogic has been bounded */
 	return 0;
 }
 EXPORT_SYMBOL_GPL(ssc_enable_vlogic_bound);

 int ssc_disable_vlogic_bound(int request_id)
 {
 	/* check counter value */
 	if (atomic_read(&vlogic_bound_counter) < 0)
 		return -1;

 	/* check request_id */
 	if (request_id < 0 || request_id >= SSC_REQUEST_NUM)
 		return -1;

 	if (atomic_dec_return(&vlogic_bound_counter) == 0)
 		return ssc_vlogic_bound_call_chain(SSC_DISABLE_VLOGIC_BOUND, request_id);

 	/* vlogic still bounded */
 	return 0;
 }
 EXPORT_SYMBOL_GPL(ssc_disable_vlogic_bound);

 #ifdef SSC_SYSFS_VLOGIC_BOUND_SUPPORT
 static ssize_t vlogic_bound_store(struct kobject *kobj,
 	struct kobj_attribute *attr, const char *buf, size_t count)
 {
 	char mode[10];

 	if (sscanf(buf, "%9s", mode) != 1)
 		return -EPERM;

 	if (strcmp(mode, "enable") == 0)
 		ssc_enable_vlogic_bound(SSC_SW);
 	else if (strcmp(mode, "disable") == 0)
 		ssc_disable_vlogic_bound(SSC_SW);

 	return count;
 }
 static ssize_t vlogic_bound_show(struct kobject *kobj,
 	struct kobj_attribute *attr, char *buf)
 {
 	int len = 0;

 	len = snprintf(buf, PAGE_SIZE, "[SSC] bound cnt = %d\n",
 			atomic_read(&vlogic_bound_counter));

 	return len;

 }
 DEFINE_ATTR_RW(vlogic_bound);
 #endif

 static unsigned int safe_vlogic_uV = 0xFFFFFFFF;
 unsigned int ssc_get_safe_vlogic_uV(void)
 {
 	return safe_vlogic_uV;
 }

 #define SSC_TIMEOUT_NUM 6
 static const char * const ssc_timeout_name[] = {
 	"SSC",
 	"GPU",
 	"ISP",
 	"CORE",
 	"APU",
 	"SRAM",
 };

 #if IS_ENABLED(CONFIG_ARM_SCMI_PROTOCOL)
 static int ssc_scmi_feature_id;
 static int plt_scmi_feature_id;

 #define SSC_TIMEOUT_MASK_SHIFT (16)

 static void ssc_notification_handler(u32 feature_id, scmi_tinysys_report *report)
 {
 #define LOG_BUF_SIZE 30
 	char log_buf[LOG_BUF_SIZE] = { 0 };
 	int log_size = 0;
 	int i, timeout;
 	int timeout_mask_shift = SSC_TIMEOUT_MASK_SHIFT;

 	if (report->p1 == SSC_STATUS_ERR) {
 		/* SSC timeout notifiy */
 		ssc_vlogic_bound_call_chain(SSC_TIMEOUT, SSC_ERR);

 		timeout = report->p2;

 		pr_info("[SSC] %s, timeout_sta = 0x%x, sram_sta = 0x%x, misc = 0x%x\n",
 			__func__, report->p2, report->p3, report->p4);

 		for (i = 1 ; i < SSC_TIMEOUT_NUM ; i++) {
 			timeout_mask_shift = (i - 1) * 2 + SSC_TIMEOUT_MASK_SHIFT;
 			if ((timeout & (0x1U << i)) &&
 			    ((timeout & (0x3 << timeout_mask_shift)) == 0x0)) {
 				log_size += scnprintf(log_buf + log_size,
 				LOG_BUF_SIZE - log_size, "%s",
 				ssc_timeout_name[i]);
 			}
 		}
 		pr_info("[SSC] CRDISPATCH_KEY:  SSC VIOLATION: %s\n", log_buf);
 		BUG_ON(1);

 	}
 }
 #endif


 static DEFINE_SPINLOCK(ssc_locker);

 static const struct of_device_id ssc_of_ids[] = {
 	{.compatible = "mediatek,ssc",},
 	{}
 };
 static int mt_ssc_pdrv_probe(struct platform_device *pdev)
 {

 	ssc_vcore_voter = regulator_get(&pdev->dev, SSC_VCORE_REGULATOR);
 	if (IS_ERR(ssc_vcore_voter)) {
 		pr_info("[SSC] get ssc vcore regulator fail\n");
 		ssc_vcore_voter = NULL;
 		return -1;
 	}
 	return 0;
 }
 static int mt_ssc_pdrv_remove(struct platform_device *pdev)
 {
 	return 0;
 }
 static struct platform_driver mt_ssc_pdrv = {
 	.probe = mt_ssc_pdrv_probe,
 	.remove = mt_ssc_pdrv_remove,
 	.driver = {
 		.name = "ssc_dvfs",
 		.owner = THIS_MODULE,
 		.of_match_table = ssc_of_ids,
 	},

 };

 static int __init ssc_init(void)
 {
 	struct device_node *ssc_node;
 	int ret;
 	unsigned long flags;
 #if IS_ENABLED(CONFIG_ARM_SCMI_PROTOCOL)
 	struct scmi_tinysys_status rvalue;
 	struct scmi_tinysys_info_st *tinfo;
 #endif

 	pr_info("[SSC] %s\n", __func__);

 	ret = platform_driver_register(&mt_ssc_pdrv);
 	if (ret)
 		pr_info("[SSC] fail to register SSC platform driver\n");

 	spin_lock_irqsave(&ssc_locker, flags);

 	ssc_node = of_find_compatible_node(NULL, NULL, MTK_SSC_DTS_COMPATIBLE);

 	ssc_enable = 0;

 	if (ssc_node) {
 		ret = of_property_read_u32(ssc_node,
 				MTK_SSC_SAFE_VLOGIC_STRING,
 				&safe_vlogic_uV);

 		pr_info("[SSC] safe_vlogic_uV = %d uV", safe_vlogic_uV);
 		/* This property is not defined*/
 		if (ret)
 			safe_vlogic_uV = 0xFFFFFFFF;

 		ret = of_property_read_u32(ssc_node,
 				"ssc_enable",
 				&ssc_enable);
 		if (ret)
 			ssc_enable = 0;

 		of_node_put(ssc_node);
 	}

 	if (ssc_enable == 0) {
 		spin_unlock_irqrestore(&ssc_locker, flags);
 		pr_info("[SSC] disabled\n");
 		return 0;
 	}

 	/* set gpu vlogic bound 0.6V if gpueb not ready */
 #if IS_ENABLED(CONFIG_GPU_SUPPORT)
 	ssc_node = of_find_compatible_node(NULL, NULL, MTK_GPU_DTS_COMPATIBLE);

 	if (ssc_node) {
 		ret = of_property_read_u32(ssc_node,
 			"gpueb-support",
 			&gpueb_enable);

 		pr_info("[SSC] gpueb enable = 0x%x\n", gpueb_enable);

 		if (gpueb_enable == 0)
 			gpufreq_set_limit(TARGET_DEFAULT, LIMIT_SRAMRC, GPUPPM_KEEP_IDX, 60000);

 		of_node_put(ssc_node);
 	}
 #endif
 	spin_unlock_irqrestore(&ssc_locker, flags);

 	/* scmi interface initialization */

 #if IS_ENABLED(CONFIG_ARM_SCMI_PROTOCOL)
 	tinfo = get_scmi_tinysys_info();
 	if (!tinfo) {
 		pr_info("[SSC] get SCMI info fail\n");
 		goto SKIP_SCMI;
 	}
 	ret = of_property_read_u32(tinfo->sdev->dev.of_node, "scmi_ssc", &ssc_scmi_feature_id);

 	pr_info("[SSC] ssc scmi id = %d\n", ssc_scmi_feature_id);

 	scmi_tinysys_register_event_notifier(ssc_scmi_feature_id,
 			(f_handler_t)ssc_notification_handler);

 	ret = scmi_tinysys_event_notify(ssc_scmi_feature_id, 1);
 	if (ret < 0)
 		pr_info("[SSC] SCMI notify register fail\n");

 	ret = of_property_read_u32(tinfo->sdev->dev.of_node, "scmi-plt", &plt_scmi_feature_id);
 	ret = scmi_tinysys_common_set(tinfo->ph, plt_scmi_feature_id, PLT_SSC_INIT,
 					0, 0, 0, 0);

 	if (ret)
 		ssc_aee_print("[SSC] SCMI common set fail!\n");
 	else
 		pr_info("[SSC] notify done! (r1:%d r2:%d r3:%d)\n",
 				rvalue.r1, rvalue.r2, rvalue.r3);
 SKIP_SCMI:
 #endif

 	ssc_vlogic_bound_register_notifier(&ssc_vlogic_notifier_func);
 	atomic_set(&vlogic_bound_counter, 0);
 	/* create sysfs entry for voltage bound */
 	ssc_kobj = kobject_create_and_add("ssc", kernel_kobj);

 #ifdef SSC_SYSFS_VLOGIC_BOUND_SUPPORT
 	if (ssc_kobj)
 		ret = sysfs_create_file(ssc_kobj, __ATTR_OF(vlogic_bound));
 #endif
 	return 0;
 }
 static void __exit ssc_deinit(void)
 {
 	if (ssc_enable == 0)
 		return;

 #ifdef SSC_SYSFS_VLOGIC_BOUND_SUPPORT
 	sysfs_remove_file(ssc_kobj, __ATTR_OF(vlogic_bound));
 #endif
 	kobject_del(ssc_kobj);
 	ssc_vlogic_bound_unregister_notifier(&ssc_vlogic_notifier_func);
 }

 module_init(ssc_init);
 module_exit(ssc_deinit);
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("mtk ssc module");
 MODULE_AUTHOR("MediaTek Inc.");
	// SPDX-License-Identifier: GPL-2.0
	/*
	* Copyright (c) 2021 MediaTek Inc.
	*/

	#include <linux/device.h>
	#include <linux/kernel.h>
	#include <linux/kobject.h>
	#include <linux/module.h>
	#include <linux/kobject.h>
	#include <linux/of.h>
	#include <linux/of_platform.h>
	#include <linux/spinlock.h>
	#include <linux/suspend.h>
	#include <linux/atomic.h>
	#include <linux/platform_device.h>
	#include <linux/regulator/consumer.h>
	#include <ssc_module.h>
	#include <mt-plat/ssc.h>

	//#define SSC_SYSFS_VLOGIC_BOUND_SUPPORT

	#if IS_ENABLED(CONFIG_MTK_AEE_FEATURE)
	#include <mt-plat/aee.h>
	#endif

	#if IS_ENABLED(CONFIG_ARM_SCMI_PROTOCOL)
	#include <linux/scmi_protocol.h>
	#include <tinysys-scmi.h>
	#endif

	#if IS_ENABLED(CONFIG_GPU_SUPPORT)
	#include <gpufreq_v2.h>
	static unsigned int gpueb_enable;
	#endif

	#if IS_ENABLED(CONFIG_MTK_AEE_FEATURE)
	#define ssc_aee_print(string, args...) do {\
	char ssc_name[100];\
	int ret;\
	ret = snprintf(ssc_name, 100, "[SSC] "string, ##args); \
	if (ret > 0)\
	aee_kernel_exception_api(__FILE__, __LINE__, \
	DB_OPT_MMPROFILE_BUFFER \| DB_OPT_NE_JBT_TRACES, \
	ssc_name, "[SSC] error:"string, ##args); \
	pr_info("[SSC] error:"string, ##args); \
	} while (0)
	#else
	#define ssc_aee_print(string, args...) \
	pr_info("[SSC] error:"string, ##args)
	#endif

	#define MTK_SSC_DTS_COMPATIBLE "mediatek,ssc"
	#define MTK_GPU_DTS_COMPATIBLE "mediatek,gpueb"
	#define SSC_VCORE_REGULATOR "dvfsrc-vcore"
	#define PLT_SSC_INIT (0x504C5403) /magic/

	struct kobject *ssc_kobj;
	EXPORT_SYMBOL_GPL(ssc_kobj);

	unsigned int ssc_enable;
	EXPORT_SYMBOL_GPL(ssc_enable);

	static BLOCKING_NOTIFIER_HEAD(vlogic_bound_chain);
	static struct regulator *ssc_vcore_voter;

	static int set_vcore_vlogic_bound(en)
	{
	int ret;

	if (!ssc_vcore_voter) {
	pr_info("[SSC] invalid vcore regulator\n");
	return -1;
	}

	if (en)
	ret = regulator_set_voltage(ssc_vcore_voter, 600000, INT_MAX);
	else
	ret = regulator_set_voltage(ssc_vcore_voter, 575000, INT_MAX);

	if (ret) {
	pr_info("[SSC] vcore vlogic bound %s fail\n", en ? "enable" : "disable");
	return -1;
	}

	return 0;
	}


	static int set_gpu_vlogic_bound(int en)
	{

	int ret = 0;

	#if IS_ENABLED(CONFIG_GPU_SUPPORT)
	/* floor value for GPU = mV * 100 */
	if (en)
	ret = gpufreq_set_limit(TARGET_DEFAULT, LIMIT_SRAMRC,
	GPUPPM_KEEP_IDX, 60000);
	else
	ret = gpufreq_set_limit(TARGET_DEFAULT, LIMIT_SRAMRC,
	GPUPPM_KEEP_IDX, GPUPPM_RESET_IDX);

	if (ret)
	pr_info("[SSC] gpu vlogic bound %s fail\n", en ? "enable" : "disable");
	#endif
	return ret;
	}

	static int ssc_vlogic_bound_event(struct notifier_block *notifier, unsigned long event,
	void *data)
	{

	unsigned int request_id = ((unsigned int )data);

	pr_info("[SSC] request ID = 0x%x, event = 0x%lx\n", request_id, event);

	switch (event) {
	case SSC_ENABLE_VLOGIC_BOUND:
	set_gpu_vlogic_bound(1);
	set_vcore_vlogic_bound(1);
	return NOTIFY_DONE;
	case SSC_DISABLE_VLOGIC_BOUND:
	set_vcore_vlogic_bound(0);
	set_gpu_vlogic_bound(0);
	return NOTIFY_DONE;
	case SSC_TIMEOUT:
	return NOTIFY_DONE;
	default:
	return NOTIFY_BAD;
	}
	return NOTIFY_OK;
	}
	static struct notifier_block ssc_vlogic_notifier_func = {
	.notifier_call = ssc_vlogic_bound_event,
	.priority = 0,
	};

	static int ssc_vlogic_bound_call_chain(unsigned int val, unsigned int request_id)
	{
	int ret;

	ret = blocking_notifier_call_chain(&vlogic_bound_chain, val, &request_id);

	if (ret == NOTIFY_DONE \|\| ret == NOTIFY_OK)
	return 0;
	else
	return -1;
	}
	static atomic_t vlogic_bound_counter;

	int ssc_vlogic_bound_register_notifier(struct notifier_block *nb)
	{
	return blocking_notifier_chain_register(&vlogic_bound_chain, nb);
	}
	EXPORT_SYMBOL_GPL(ssc_vlogic_bound_register_notifier);

	int ssc_vlogic_bound_unregister_notifier(struct notifier_block *nb)
	{
	return blocking_notifier_chain_unregister(&vlogic_bound_chain, nb);
	}
	EXPORT_SYMBOL_GPL(ssc_vlogic_bound_unregister_notifier);


	int ssc_enable_vlogic_bound(int request_id)
	{
	/* check counter value */
	if (atomic_read(&vlogic_bound_counter) < 0)
	return -1;

	/* check request_id */
	if (request_id < 0 \|\| request_id >= SSC_REQUEST_NUM)
	return -1;

	if (atomic_inc_return(&vlogic_bound_counter) == 1)
	return ssc_vlogic_bound_call_chain(SSC_ENABLE_VLOGIC_BOUND, request_id);

	/* vlogic has been bounded */
	return 0;
	}
	EXPORT_SYMBOL_GPL(ssc_enable_vlogic_bound);

	int ssc_disable_vlogic_bound(int request_id)
	{
	/* check counter value */
	if (atomic_read(&vlogic_bound_counter) < 0)
	return -1;

	/* check request_id */
	if (request_id < 0 \|\| request_id >= SSC_REQUEST_NUM)
	return -1;

	if (atomic_dec_return(&vlogic_bound_counter) == 0)
	return ssc_vlogic_bound_call_chain(SSC_DISABLE_VLOGIC_BOUND, request_id);

	/* vlogic still bounded */
	return 0;
	}
	EXPORT_SYMBOL_GPL(ssc_disable_vlogic_bound);

	#ifdef SSC_SYSFS_VLOGIC_BOUND_SUPPORT
	static ssize_t vlogic_bound_store(struct kobject *kobj,
	struct kobj_attribute attr, const char buf, size_t count)
	{
	char mode[10];

	if (sscanf(buf, "%9s", mode) != 1)
	return -EPERM;

	if (strcmp(mode, "enable") == 0)
	ssc_enable_vlogic_bound(SSC_SW);
	else if (strcmp(mode, "disable") == 0)
	ssc_disable_vlogic_bound(SSC_SW);

	return count;
	}
	static ssize_t vlogic_bound_show(struct kobject *kobj,
	struct kobj_attribute attr, char buf)
	{
	int len = 0;

	len = snprintf(buf, PAGE_SIZE, "[SSC] bound cnt = %d\n",
	atomic_read(&vlogic_bound_counter));

	return len;

	}
	DEFINE_ATTR_RW(vlogic_bound);
	#endif

	static unsigned int safe_vlogic_uV = 0xFFFFFFFF;
	unsigned int ssc_get_safe_vlogic_uV(void)
	{
	return safe_vlogic_uV;
	}

	#define SSC_TIMEOUT_NUM 6
	static const char * const ssc_timeout_name[] = {
	"SSC",
	"GPU",
	"ISP",
	"CORE",
	"APU",
	"SRAM",
	};

	#if IS_ENABLED(CONFIG_ARM_SCMI_PROTOCOL)
	static int ssc_scmi_feature_id;
	static int plt_scmi_feature_id;

	#define SSC_TIMEOUT_MASK_SHIFT (16)

	static void ssc_notification_handler(u32 feature_id, scmi_tinysys_report *report)
	{
	#define LOG_BUF_SIZE 30
	char log_buf[LOG_BUF_SIZE] = { 0 };
	int log_size = 0;
	int i, timeout;
	int timeout_mask_shift = SSC_TIMEOUT_MASK_SHIFT;

	if (report->p1 == SSC_STATUS_ERR) {
	/* SSC timeout notifiy */
	ssc_vlogic_bound_call_chain(SSC_TIMEOUT, SSC_ERR);

	timeout = report->p2;

	pr_info("[SSC] %s, timeout_sta = 0x%x, sram_sta = 0x%x, misc = 0x%x\n",
	__func__, report->p2, report->p3, report->p4);

	for (i = 1 ; i < SSC_TIMEOUT_NUM ; i++) {
	timeout_mask_shift = (i - 1) * 2 + SSC_TIMEOUT_MASK_SHIFT;
	if ((timeout & (0x1U << i)) &&
	((timeout & (0x3 << timeout_mask_shift)) == 0x0)) {
	log_size += scnprintf(log_buf + log_size,
	LOG_BUF_SIZE - log_size, "%s",
	ssc_timeout_name[i]);
	}
	}
	pr_info("[SSC] CRDISPATCH_KEY: SSC VIOLATION: %s\n", log_buf);
	BUG_ON(1);

	}
	}
	#endif


	static DEFINE_SPINLOCK(ssc_locker);

	static const struct of_device_id ssc_of_ids[] = {
	{.compatible = "mediatek,ssc",},
	{}
	};
	static int mt_ssc_pdrv_probe(struct platform_device *pdev)
	{

	ssc_vcore_voter = regulator_get(&pdev->dev, SSC_VCORE_REGULATOR);
	if (IS_ERR(ssc_vcore_voter)) {
	pr_info("[SSC] get ssc vcore regulator fail\n");
	ssc_vcore_voter = NULL;
	return -1;
	}
	return 0;
	}
	static int mt_ssc_pdrv_remove(struct platform_device *pdev)
	{
	return 0;
	}
	static struct platform_driver mt_ssc_pdrv = {
	.probe = mt_ssc_pdrv_probe,
	.remove = mt_ssc_pdrv_remove,
	.driver = {
	.name = "ssc_dvfs",
	.owner = THIS_MODULE,
	.of_match_table = ssc_of_ids,
	},

	};

	static int __init ssc_init(void)
	{
	struct device_node *ssc_node;
	int ret;
	unsigned long flags;
	#if IS_ENABLED(CONFIG_ARM_SCMI_PROTOCOL)
	struct scmi_tinysys_status rvalue;
	struct scmi_tinysys_info_st *tinfo;
	#endif

	pr_info("[SSC] %s\n", __func__);

	ret = platform_driver_register(&mt_ssc_pdrv);
	if (ret)
	pr_info("[SSC] fail to register SSC platform driver\n");

	spin_lock_irqsave(&ssc_locker, flags);

	ssc_node = of_find_compatible_node(NULL, NULL, MTK_SSC_DTS_COMPATIBLE);

	ssc_enable = 0;

	if (ssc_node) {
	ret = of_property_read_u32(ssc_node,
	MTK_SSC_SAFE_VLOGIC_STRING,
	&safe_vlogic_uV);

	pr_info("[SSC] safe_vlogic_uV = %d uV", safe_vlogic_uV);
	/* This property is not defined*/
	if (ret)
	safe_vlogic_uV = 0xFFFFFFFF;

	ret = of_property_read_u32(ssc_node,
	"ssc_enable",
	&ssc_enable);
	if (ret)
	ssc_enable = 0;

	of_node_put(ssc_node);
	}

	if (ssc_enable == 0) {
	spin_unlock_irqrestore(&ssc_locker, flags);
	pr_info("[SSC] disabled\n");
	return 0;
	}

	/* set gpu vlogic bound 0.6V if gpueb not ready */
	#if IS_ENABLED(CONFIG_GPU_SUPPORT)
	ssc_node = of_find_compatible_node(NULL, NULL, MTK_GPU_DTS_COMPATIBLE);

	if (ssc_node) {
	ret = of_property_read_u32(ssc_node,
	"gpueb-support",
	&gpueb_enable);

	pr_info("[SSC] gpueb enable = 0x%x\n", gpueb_enable);

	if (gpueb_enable == 0)
	gpufreq_set_limit(TARGET_DEFAULT, LIMIT_SRAMRC, GPUPPM_KEEP_IDX, 60000);

	of_node_put(ssc_node);
	}
	#endif
	spin_unlock_irqrestore(&ssc_locker, flags);

	/* scmi interface initialization */

	#if IS_ENABLED(CONFIG_ARM_SCMI_PROTOCOL)
	tinfo = get_scmi_tinysys_info();
	if (!tinfo) {
	pr_info("[SSC] get SCMI info fail\n");
	goto SKIP_SCMI;
	}
	ret = of_property_read_u32(tinfo->sdev->dev.of_node, "scmi_ssc", &ssc_scmi_feature_id);

	pr_info("[SSC] ssc scmi id = %d\n", ssc_scmi_feature_id);

	scmi_tinysys_register_event_notifier(ssc_scmi_feature_id,
	(f_handler_t)ssc_notification_handler);

	ret = scmi_tinysys_event_notify(ssc_scmi_feature_id, 1);
	if (ret < 0)
	pr_info("[SSC] SCMI notify register fail\n");

	ret = of_property_read_u32(tinfo->sdev->dev.of_node, "scmi-plt", &plt_scmi_feature_id);
	ret = scmi_tinysys_common_set(tinfo->ph, plt_scmi_feature_id, PLT_SSC_INIT,
	0, 0, 0, 0);

	if (ret)
	ssc_aee_print("[SSC] SCMI common set fail!\n");
	else
	pr_info("[SSC] notify done! (r1:%d r2:%d r3:%d)\n",
	rvalue.r1, rvalue.r2, rvalue.r3);
	SKIP_SCMI:
	#endif

	ssc_vlogic_bound_register_notifier(&ssc_vlogic_notifier_func);
	atomic_set(&vlogic_bound_counter, 0);
	/* create sysfs entry for voltage bound */
	ssc_kobj = kobject_create_and_add("ssc", kernel_kobj);

	#ifdef SSC_SYSFS_VLOGIC_BOUND_SUPPORT
	if (ssc_kobj)
	ret = sysfs_create_file(ssc_kobj, __ATTR_OF(vlogic_bound));
	#endif
	return 0;
	}
	static void __exit ssc_deinit(void)
	{
	if (ssc_enable == 0)
	return;

	#ifdef SSC_SYSFS_VLOGIC_BOUND_SUPPORT
	sysfs_remove_file(ssc_kobj, __ATTR_OF(vlogic_bound));
	#endif
	kobject_del(ssc_kobj);
	ssc_vlogic_bound_unregister_notifier(&ssc_vlogic_notifier_func);
	}

	module_init(ssc_init);
	module_exit(ssc_deinit);
	MODULE_LICENSE("GPL");
	MODULE_DESCRIPTION("mtk ssc module");
	MODULE_AUTHOR("MediaTek Inc.");