drivers/vision/npu/npu-qos.c - LeafOS-Devices/android_kernel_samsung_exynos9820 - Gitiles

 /*
  * Samsung Exynos SoC series NPU driver
  *
  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
  *              http://www.samsung.com/
  *
  * 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/pm_qos.h>
 #include <linux/pm_opp.h>
 #include <linux/mutex.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>

 #include "npu-vs4l.h"
 #include "npu-device.h"
 #include "npu-memory.h"
 #include "npu-system.h"
 #include "npu-qos.h"


 #ifdef CONFIG_ARCH_EXYNOS
 #if defined(CONFIG_SOC_EXYNOS9820)
 #define NPU_PM_QOS_NPU		(PM_QOS_NPU_THROUGHPUT)
 #define NPU_PM_QOS_DEFAULT_FREQ (666000)
 #define NPU_PM_NPU_MIN		(222000)
 #define NPU_PM_NPU_MAX		(933000)


 #define NPU_PM_QOS_MIF		(PM_QOS_BUS_THROUGHPUT)
 #define NPU_PM_MIF_MIN		(421000)
 #define NPU_PM_MIF_REQ		(1352000)
 #define NPU_PM_MIF_MAX		(2093000)

 #define NPU_PM_QOS_INT		(PM_QOS_DEVICE_THROUGHPUT)
 #define NPU_PM_INT_MIN		(100000)
 #define NPU_PM_INT_MAX		(534000)

 #define NPU_PM_CPU_CL0		(PM_QOS_CLUSTER0_FREQ_MIN)
 #define NPU_PM_CPU_CL0_MIN	(442000)
 #define NPU_PM_CPU_CL0_MAX	(1742000)

 #define NPU_PM_CPU_CL1		(PM_QOS_CLUSTER1_FREQ_MIN)
 #define NPU_PM_CPU_CL1_MIN	(507000)
 #define NPU_PM_CPU_CL1_MAX	(1898000)

 #define NPU_PM_CPU_CL2		(PM_QOS_CLUSTER2_FREQ_MIN)
 #define NPU_PM_CPU_CL2_MIN	(520000)
 #define NPU_PM_CPU_CL2_MAX	(2470000)

 #define NPU_PM_CPU_ONLINE_MIN	0
 #define NPU_PM_CPU_ONLINE_MAX	6


 #else
 #undef NPU_PM_QOS_NPU
 #define NPU_PM_NPU_MIN		(167000)
 #endif
 #endif

 static struct npu_qos_setting *qos_setting;
 static LIST_HEAD(qos_list);
 static int npu_sysfs_print(char *buf, size_t buf_sz, const char *fmt, ...)
 {
 	int	strlen;
 	va_list	ap;

 	va_start(ap, fmt);
 	strlen = vsnprintf(buf, buf_sz, fmt, ap);
 	va_end(ap);

 	return strlen;
 }

 #define NPU_SYSFS_PRINT(buf, buf_size, tmp_buf, tmp_size, format, ...)	\
 	do {									\
 		tmp_size = npu_sysfs_print(tmp_buf, sizeof(tmp_buf),		\
 						format, ## __VA_ARGS__);	\
 		if ((buf_size + tmp_size + 1) > PAGE_SIZE)			\
 			goto exit;	/* no space */				\
 		strncat(buf, tmp_buf, tmp_size);				\
 		buf_size += tmp_size;						\
 	} while (0)


 static ssize_t npu_sysfs_show_qos(struct device *dev,
 		struct device_attribute *dev_attr, char *buf)
 {
 	struct device *dvfs_dev;
 	struct dev_pm_opp *opp;
 	ssize_t		buf_size = 0;
 	char		tmp_buf[256];
 	int		tmp_size;
 	unsigned long	freq = 0;

 	buf[0] = 0;

 	if (!qos_setting) {
 		dev_warn(dev, "No qos_setting in device.\n");
 		goto exit;
 	}

 	dvfs_dev = &qos_setting->dvfs_npu_dev->dev;

 	NPU_SYSFS_PRINT(buf, buf_size, tmp_buf, tmp_size,
 			"# DVFS table:\n  ");
 	do {
 		opp = dev_pm_opp_find_freq_ceil(dvfs_dev, &freq);
 		if (IS_ERR(opp))
 			break;

 		NPU_SYSFS_PRINT(buf, buf_size, tmp_buf, tmp_size,
 				"%lu%s%s ", freq,
 				(freq == qos_setting->current_freq) ?
 				"(*)" : "",
 				(freq == qos_setting->request_freq) ?
 				"(R)" : "");
 		freq++;
 		dev_pm_opp_put(opp);
 	} while (1);

 	NPU_SYSFS_PRINT(buf, buf_size, tmp_buf, tmp_size,
 			"\n\n# default: %d KHz / request: %d KHz / current: %d KHz\n\n",
 			qos_setting->default_freq,
 			qos_setting->request_freq, qos_setting->current_freq);

 exit:
 	return buf_size;
 }

 static ssize_t npu_sysfs_set_qos(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
 	struct device *dvfs_dev;
 	struct dev_pm_opp *opp;
 	unsigned long freq = 0;
 	bool hit = false;
 	int  value, err;

 	err = kstrtoint(buf, 10, &value);
 	if (err) {
 		dev_err(dev, "only decimal value allowed (input: %s)\n", buf);
 		return count;
 	}

 	if (!qos_setting->dvfs_npu_dev) {
 		dev_warn(dev, "npu drivers does not connect with dvfs table\n");
 		return count;
 	}

 	dvfs_dev = &qos_setting->dvfs_npu_dev->dev;

 	do {
 		opp = dev_pm_opp_find_freq_ceil(dvfs_dev, &freq);
 		if (IS_ERR(opp))
 			break;

 		if (freq == (int)value) {
 			hit = true;
 			dev_pm_opp_put(opp);
 			break;
 		}
 		dev_pm_opp_put(opp);
 		freq++;

 	} while (1);

 	if (hit)
 		qos_setting->request_freq = (s32)value;
 	else
 		dev_warn(dev, "fail to set qos_rate (req %d KHz) and"
 			"(current %d KHz)\n", value, qos_setting->current_freq);

 	return count;
 }

 static DEVICE_ATTR(qos_rate, 0644, npu_sysfs_show_qos, npu_sysfs_set_qos);
 static struct attribute *npu_qos_attributes[] = {
 	&dev_attr_qos_rate.attr,
 	NULL,
 };

 static struct attribute_group npu_attr_group = {
 	.attrs = npu_qos_attributes,
 };

 int npu_qos_probe(struct npu_system *system)
 {
 	struct device *dev = &system->pdev->dev;
 	struct device_node *of_node = dev->of_node;
 	struct device_node *child_node;

 	qos_setting = &(system->qos_setting);

 	mutex_init(&qos_setting->npu_qos_lock);

 	/* parse dts and fill data */
 	child_node = of_parse_phandle(of_node, "dvfs-dev", 0);
 	qos_setting->dvfs_npu_dev = of_find_device_by_node(child_node);
 	if (!qos_setting->dvfs_npu_dev)
 		dev_warn(dev, "fail to get npu dvfs_dev\n");

 	if (of_property_read_s32(of_node, "npu_default_qos_rate",
 				&qos_setting->default_freq))
 		qos_setting->default_freq = NPU_PM_NPU_MIN;

 	qos_setting->request_freq = qos_setting->default_freq;

 	/* qos add request(default_freq) */
 #ifdef NPU_PM_QOS_NPU
 	pm_qos_add_request(&qos_setting->npu_qos_req_npu, NPU_PM_QOS_NPU, 0);
 	pm_qos_add_request(&qos_setting->npu_qos_req_mif, NPU_PM_QOS_MIF, 0);
 	pm_qos_add_request(&qos_setting->npu_qos_req_int, NPU_PM_QOS_INT, 0);

 	pm_qos_add_request(&qos_setting->npu_qos_req_cpu_cl0, NPU_PM_CPU_CL0, 0);
 	pm_qos_add_request(&qos_setting->npu_qos_req_cpu_cl1, NPU_PM_CPU_CL1, 0);
 	pm_qos_add_request(&qos_setting->npu_qos_req_cpu_cl2, NPU_PM_CPU_CL2, 0);

 	qos_setting->current_freq = qos_setting->default_freq;
 #else
 	qos_setting->default_freq = NPU_PM_NPU_MIN;
 	qos_setting->current_freq = NPU_PM_NPU_MIN;
 #endif
 	qos_setting->req_cl0_freq = 0;
 	qos_setting->req_cl1_freq = 0;
 	qos_setting->req_cl2_freq = 0;

 	return sysfs_create_group(&dev->kobj, &npu_attr_group);
 }

 int npu_qos_release(struct npu_system *system)
 {
 	struct device *dev = &system->pdev->dev;

 	sysfs_remove_group(&dev->kobj, &npu_attr_group);

 	return 0;
 }

 int npu_qos_start(struct npu_system *system)
 {
 	int cur_value;

 	BUG_ON(!system);

 	mutex_lock(&qos_setting->npu_qos_lock);

 	if (qos_setting->current_freq != qos_setting->request_freq)
 		qos_setting->current_freq = qos_setting->request_freq;
 #ifdef NPU_PM_QOS_NPU
 	if (qos_setting->req_npu_freq <= qos_setting->current_freq)
 		pm_qos_update_request(&qos_setting->npu_qos_req_npu, qos_setting->current_freq);
 #endif
 	mutex_unlock(&qos_setting->npu_qos_lock);
 	cur_value = (s32)pm_qos_read_req_value(qos_setting->npu_qos_req_npu.pm_qos_class,
 		&qos_setting->npu_qos_req_npu);
 	npu_info("%s() npu_qos_rate(%d)\n", __func__, cur_value);
 	qos_setting->req_cl0_freq = 0;
 	qos_setting->req_cl1_freq = 0;
 	qos_setting->req_cl2_freq = 0;
 	return 0;
 }

 int npu_qos_stop(struct npu_system *system)
 {
 	struct list_head *pos, *q;
 	struct npu_session_qos_req *qr;
 	int cur_value;

 	BUG_ON(!system);

 	mutex_lock(&qos_setting->npu_qos_lock);

 	list_for_each_safe(pos, q, &qos_list) {
 		qr = list_entry(pos, struct npu_session_qos_req, list);
 		list_del(pos);
 		if (qr)
 			kfree(qr);
 	}
 	list_del_init(&qos_list);

 #ifdef NPU_PM_QOS_NPU
 	pm_qos_update_request(&qos_setting->npu_qos_req_npu, NPU_PM_NPU_MIN);
 	pm_qos_update_request(&qos_setting->npu_qos_req_mif, 0);
 	pm_qos_update_request(&qos_setting->npu_qos_req_int, 0);

 	pm_qos_update_request(&qos_setting->npu_qos_req_cpu_cl0, 0);
 	pm_qos_update_request(&qos_setting->npu_qos_req_cpu_cl1, 0);
 	pm_qos_update_request(&qos_setting->npu_qos_req_cpu_cl2, 0);
 #endif
 	qos_setting->req_npu_freq = 0;
 	mutex_unlock(&qos_setting->npu_qos_lock);
 	cur_value = (s32)pm_qos_read_req_value(qos_setting->npu_qos_req_npu.pm_qos_class,
 		&qos_setting->npu_qos_req_npu);
 	npu_info("%s() npu_qos_rate(%d)\n", __func__, cur_value);

 	return 0;
 }


 s32 __update_freq_from_showcase(__u32 nCategory)
 {
 	s32 nValue = 0;
 	struct list_head *pos, *q;
 	struct npu_session_qos_req *qr;

 	list_for_each_safe(pos, q, &qos_list) {
 		qr = list_entry(pos, struct npu_session_qos_req, list);
 		if (qr->eCategory == nCategory) {
 			nValue = qr->req_freq > nValue ? qr->req_freq : nValue;
 			npu_dbg("[U%u]Candidate Freq. category : %u  freq : %d\n",
 				qr->sessionUID, nCategory, nValue);
 		}
 	}

 	return nValue;
 }

 int __req_param_qos(int uid, __u32 nCategory, struct pm_qos_request *req, s32 new_value)
 {
 	int ret = 0;
 	s32 cur_value, rec_value;
 	struct list_head *pos, *q;
 	struct npu_session_qos_req *qr;

 	//Check that same uid, and category whether already registered.
 	list_for_each_safe(pos, q, &qos_list) {
 		qr = list_entry(pos, struct npu_session_qos_req, list);
 		if ((qr->sessionUID == uid) && (qr->eCategory == nCategory)) {
 			cur_value = qr->req_freq;
 			npu_dbg("[U%u]Change Req Freq. category : %u, from freq : %d to %d\n",
 					uid, nCategory, cur_value, new_value);
 			list_del(pos);
 			qr->sessionUID = uid;
 			qr->req_freq = new_value;
 			qr->eCategory = nCategory;
 			list_add_tail(&qr->list, &qos_list);
 			rec_value = __update_freq_from_showcase(nCategory);

 			if (new_value > rec_value) {
 				pm_qos_update_request(req, new_value);
 				npu_dbg("[U%u]Changed Freq. category : %u, from freq : %d to %d\n",
 					uid, nCategory, cur_value, new_value);
 			} else {
 				pm_qos_update_request(req, rec_value);
 				npu_dbg("[U%u]Recovered Freq. category : %u, from freq : %d to %d\n",
 					uid, nCategory, cur_value, rec_value);
 			}
 			return ret;
 		}
 	}
 	//No Same uid, and category. Add new item
 	qr = kmalloc(sizeof(struct npu_session_qos_req), GFP_KERNEL);
 	if (!qr) {
 		npu_err("memory alloc fail.\n");
 		return -ENOMEM;
 	}
 	qr->sessionUID = uid;
 	qr->req_freq = new_value;
 	qr->eCategory = nCategory;
 	list_add_tail(&qr->list, &qos_list);

 	//If new_value is lager than current value, update the freq
 	cur_value = (s32)pm_qos_read_req_value(req->pm_qos_class, req);
 	npu_dbg("[U%u]New Freq. category : %u freq : %u\n",
 		qr->sessionUID, qr->eCategory, qr->req_freq);
 	if (cur_value < new_value) {
 		npu_dbg("[U%u]Update Freq. category : %u freq : %u\n",
 			qr->sessionUID, qr->eCategory, qr->req_freq);
 		pm_qos_update_request(req, new_value);
 	}
 	return ret;
 }

 npu_s_param_ret npu_qos_param_handler(struct npu_session *sess, struct vs4l_param *param, int *retval)
 {
 	BUG_ON(!sess);
 	BUG_ON(!param);

 	mutex_lock(&qos_setting->npu_qos_lock);

 	switch (param->target) {
 	case NPU_S_PARAM_QOS_NPU:
 		qos_setting->req_npu_freq = param->offset;
 		//Set minimum safe clock as default  to avoid NDONE
 		if (qos_setting->req_npu_freq < qos_setting->default_freq)
 			qos_setting->req_npu_freq = qos_setting->default_freq;
 		__req_param_qos(sess->uid, param->target, &qos_setting->npu_qos_req_npu, qos_setting->req_npu_freq);

 		mutex_unlock(&qos_setting->npu_qos_lock);
 		return S_PARAM_HANDLED;
 	case NPU_S_PARAM_QOS_MIF:
 		qos_setting->req_mif_freq = param->offset;
 		__req_param_qos(sess->uid, param->target, &qos_setting->npu_qos_req_mif, qos_setting->req_mif_freq);

 		mutex_unlock(&qos_setting->npu_qos_lock);
 		return S_PARAM_HANDLED;
 	case NPU_S_PARAM_QOS_INT:
 		qos_setting->req_int_freq = param->offset;
 		__req_param_qos(sess->uid, param->target, &qos_setting->npu_qos_req_int, qos_setting->req_int_freq);

 		mutex_unlock(&qos_setting->npu_qos_lock);
 		return S_PARAM_HANDLED;
 	case NPU_S_PARAM_QOS_CL0:
 		qos_setting->req_cl0_freq = param->offset;
 		__req_param_qos(sess->uid, param->target, &qos_setting->npu_qos_req_cpu_cl0, qos_setting->req_cl0_freq);

 		mutex_unlock(&qos_setting->npu_qos_lock);
 		return S_PARAM_HANDLED;
 	case NPU_S_PARAM_QOS_CL1:
 		qos_setting->req_cl1_freq = param->offset;
 		__req_param_qos(sess->uid, param->target, &qos_setting->npu_qos_req_cpu_cl1, qos_setting->req_cl1_freq);

 		mutex_unlock(&qos_setting->npu_qos_lock);
 		return S_PARAM_HANDLED;
 	case NPU_S_PARAM_QOS_CL2:
 		qos_setting->req_cl2_freq = param->offset;
 		__req_param_qos(sess->uid, param->target, &qos_setting->npu_qos_req_cpu_cl2, qos_setting->req_cl2_freq);

 		mutex_unlock(&qos_setting->npu_qos_lock);
 		return S_PARAM_HANDLED;
 	case NPU_S_PARAM_CPU_AFF:
 	case NPU_S_PARAM_QOS_RST:
 	default:
 		mutex_unlock(&qos_setting->npu_qos_lock);
 		return S_PARAM_NOMB;
 	}
 }
	/*
	* Samsung Exynos SoC series NPU driver
	*
	* Copyright (c) 2017 Samsung Electronics Co., Ltd.
	* http://www.samsung.com/
	*
	* 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/pm_qos.h>
	#include <linux/pm_opp.h>
	#include <linux/mutex.h>
	#include <linux/of.h>
	#include <linux/of_platform.h>

	#include "npu-vs4l.h"
	#include "npu-device.h"
	#include "npu-memory.h"
	#include "npu-system.h"
	#include "npu-qos.h"


	#ifdef CONFIG_ARCH_EXYNOS
	#if defined(CONFIG_SOC_EXYNOS9820)
	#define NPU_PM_QOS_NPU (PM_QOS_NPU_THROUGHPUT)
	#define NPU_PM_QOS_DEFAULT_FREQ (666000)
	#define NPU_PM_NPU_MIN (222000)
	#define NPU_PM_NPU_MAX (933000)


	#define NPU_PM_QOS_MIF (PM_QOS_BUS_THROUGHPUT)
	#define NPU_PM_MIF_MIN (421000)
	#define NPU_PM_MIF_REQ (1352000)
	#define NPU_PM_MIF_MAX (2093000)

	#define NPU_PM_QOS_INT (PM_QOS_DEVICE_THROUGHPUT)
	#define NPU_PM_INT_MIN (100000)
	#define NPU_PM_INT_MAX (534000)

	#define NPU_PM_CPU_CL0 (PM_QOS_CLUSTER0_FREQ_MIN)
	#define NPU_PM_CPU_CL0_MIN (442000)
	#define NPU_PM_CPU_CL0_MAX (1742000)

	#define NPU_PM_CPU_CL1 (PM_QOS_CLUSTER1_FREQ_MIN)
	#define NPU_PM_CPU_CL1_MIN (507000)
	#define NPU_PM_CPU_CL1_MAX (1898000)

	#define NPU_PM_CPU_CL2 (PM_QOS_CLUSTER2_FREQ_MIN)
	#define NPU_PM_CPU_CL2_MIN (520000)
	#define NPU_PM_CPU_CL2_MAX (2470000)

	#define NPU_PM_CPU_ONLINE_MIN 0
	#define NPU_PM_CPU_ONLINE_MAX 6


	#else
	#undef NPU_PM_QOS_NPU
	#define NPU_PM_NPU_MIN (167000)
	#endif
	#endif

	static struct npu_qos_setting *qos_setting;
	static LIST_HEAD(qos_list);
	static int npu_sysfs_print(char buf, size_t buf_sz, const char fmt, ...)
	{
	int strlen;
	va_list ap;

	va_start(ap, fmt);
	strlen = vsnprintf(buf, buf_sz, fmt, ap);
	va_end(ap);

	return strlen;
	}

	#define NPU_SYSFS_PRINT(buf, buf_size, tmp_buf, tmp_size, format, ...) \
	do { \
	tmp_size = npu_sysfs_print(tmp_buf, sizeof(tmp_buf), \
	format, ## __VA_ARGS__); \
	if ((buf_size + tmp_size + 1) > PAGE_SIZE) \
	goto exit; /* no space */ \
	strncat(buf, tmp_buf, tmp_size); \
	buf_size += tmp_size; \
	} while (0)


	static ssize_t npu_sysfs_show_qos(struct device *dev,
	struct device_attribute dev_attr, char buf)
	{
	struct device *dvfs_dev;
	struct dev_pm_opp *opp;
	ssize_t buf_size = 0;
	char tmp_buf[256];
	int tmp_size;
	unsigned long freq = 0;

	buf[0] = 0;

	if (!qos_setting) {
	dev_warn(dev, "No qos_setting in device.\n");
	goto exit;
	}

	dvfs_dev = &qos_setting->dvfs_npu_dev->dev;

	NPU_SYSFS_PRINT(buf, buf_size, tmp_buf, tmp_size,
	"# DVFS table:\n ");
	do {
	opp = dev_pm_opp_find_freq_ceil(dvfs_dev, &freq);
	if (IS_ERR(opp))
	break;

	NPU_SYSFS_PRINT(buf, buf_size, tmp_buf, tmp_size,
	"%lu%s%s ", freq,
	(freq == qos_setting->current_freq) ?
	"(*)" : "",
	(freq == qos_setting->request_freq) ?
	"(R)" : "");
	freq++;
	dev_pm_opp_put(opp);
	} while (1);

	NPU_SYSFS_PRINT(buf, buf_size, tmp_buf, tmp_size,
	"\n\n# default: %d KHz / request: %d KHz / current: %d KHz\n\n",
	qos_setting->default_freq,
	qos_setting->request_freq, qos_setting->current_freq);

	exit:
	return buf_size;
	}

	static ssize_t npu_sysfs_set_qos(struct device *dev,
	struct device_attribute attr, const char buf, size_t count)
	{
	struct device *dvfs_dev;
	struct dev_pm_opp *opp;
	unsigned long freq = 0;
	bool hit = false;
	int value, err;

	err = kstrtoint(buf, 10, &value);
	if (err) {
	dev_err(dev, "only decimal value allowed (input: %s)\n", buf);
	return count;
	}

	if (!qos_setting->dvfs_npu_dev) {
	dev_warn(dev, "npu drivers does not connect with dvfs table\n");
	return count;
	}

	dvfs_dev = &qos_setting->dvfs_npu_dev->dev;

	do {
	opp = dev_pm_opp_find_freq_ceil(dvfs_dev, &freq);
	if (IS_ERR(opp))
	break;

	if (freq == (int)value) {
	hit = true;
	dev_pm_opp_put(opp);
	break;
	}
	dev_pm_opp_put(opp);
	freq++;

	} while (1);

	if (hit)
	qos_setting->request_freq = (s32)value;
	else
	dev_warn(dev, "fail to set qos_rate (req %d KHz) and"
	"(current %d KHz)\n", value, qos_setting->current_freq);

	return count;
	}

	static DEVICE_ATTR(qos_rate, 0644, npu_sysfs_show_qos, npu_sysfs_set_qos);
	static struct attribute *npu_qos_attributes[] = {
	&dev_attr_qos_rate.attr,
	NULL,
	};

	static struct attribute_group npu_attr_group = {
	.attrs = npu_qos_attributes,
	};

	int npu_qos_probe(struct npu_system *system)
	{
	struct device *dev = &system->pdev->dev;
	struct device_node *of_node = dev->of_node;
	struct device_node *child_node;

	qos_setting = &(system->qos_setting);

	mutex_init(&qos_setting->npu_qos_lock);

	/* parse dts and fill data */
	child_node = of_parse_phandle(of_node, "dvfs-dev", 0);
	qos_setting->dvfs_npu_dev = of_find_device_by_node(child_node);
	if (!qos_setting->dvfs_npu_dev)
	dev_warn(dev, "fail to get npu dvfs_dev\n");

	if (of_property_read_s32(of_node, "npu_default_qos_rate",
	&qos_setting->default_freq))
	qos_setting->default_freq = NPU_PM_NPU_MIN;

	qos_setting->request_freq = qos_setting->default_freq;

	/* qos add request(default_freq) */
	#ifdef NPU_PM_QOS_NPU
	pm_qos_add_request(&qos_setting->npu_qos_req_npu, NPU_PM_QOS_NPU, 0);
	pm_qos_add_request(&qos_setting->npu_qos_req_mif, NPU_PM_QOS_MIF, 0);
	pm_qos_add_request(&qos_setting->npu_qos_req_int, NPU_PM_QOS_INT, 0);

	pm_qos_add_request(&qos_setting->npu_qos_req_cpu_cl0, NPU_PM_CPU_CL0, 0);
	pm_qos_add_request(&qos_setting->npu_qos_req_cpu_cl1, NPU_PM_CPU_CL1, 0);
	pm_qos_add_request(&qos_setting->npu_qos_req_cpu_cl2, NPU_PM_CPU_CL2, 0);

	qos_setting->current_freq = qos_setting->default_freq;
	#else
	qos_setting->default_freq = NPU_PM_NPU_MIN;
	qos_setting->current_freq = NPU_PM_NPU_MIN;
	#endif
	qos_setting->req_cl0_freq = 0;
	qos_setting->req_cl1_freq = 0;
	qos_setting->req_cl2_freq = 0;

	return sysfs_create_group(&dev->kobj, &npu_attr_group);
	}

	int npu_qos_release(struct npu_system *system)
	{
	struct device *dev = &system->pdev->dev;

	sysfs_remove_group(&dev->kobj, &npu_attr_group);

	return 0;
	}

	int npu_qos_start(struct npu_system *system)
	{
	int cur_value;

	BUG_ON(!system);

	mutex_lock(&qos_setting->npu_qos_lock);

	if (qos_setting->current_freq != qos_setting->request_freq)
	qos_setting->current_freq = qos_setting->request_freq;
	#ifdef NPU_PM_QOS_NPU
	if (qos_setting->req_npu_freq <= qos_setting->current_freq)
	pm_qos_update_request(&qos_setting->npu_qos_req_npu, qos_setting->current_freq);
	#endif
	mutex_unlock(&qos_setting->npu_qos_lock);
	cur_value = (s32)pm_qos_read_req_value(qos_setting->npu_qos_req_npu.pm_qos_class,
	&qos_setting->npu_qos_req_npu);
	npu_info("%s() npu_qos_rate(%d)\n", __func__, cur_value);
	qos_setting->req_cl0_freq = 0;
	qos_setting->req_cl1_freq = 0;
	qos_setting->req_cl2_freq = 0;
	return 0;
	}

	int npu_qos_stop(struct npu_system *system)
	{
	struct list_head pos, q;
	struct npu_session_qos_req *qr;
	int cur_value;

	BUG_ON(!system);

	mutex_lock(&qos_setting->npu_qos_lock);

	list_for_each_safe(pos, q, &qos_list) {
	qr = list_entry(pos, struct npu_session_qos_req, list);
	list_del(pos);
	if (qr)
	kfree(qr);
	}
	list_del_init(&qos_list);

	#ifdef NPU_PM_QOS_NPU
	pm_qos_update_request(&qos_setting->npu_qos_req_npu, NPU_PM_NPU_MIN);
	pm_qos_update_request(&qos_setting->npu_qos_req_mif, 0);
	pm_qos_update_request(&qos_setting->npu_qos_req_int, 0);

	pm_qos_update_request(&qos_setting->npu_qos_req_cpu_cl0, 0);
	pm_qos_update_request(&qos_setting->npu_qos_req_cpu_cl1, 0);
	pm_qos_update_request(&qos_setting->npu_qos_req_cpu_cl2, 0);
	#endif
	qos_setting->req_npu_freq = 0;
	mutex_unlock(&qos_setting->npu_qos_lock);
	cur_value = (s32)pm_qos_read_req_value(qos_setting->npu_qos_req_npu.pm_qos_class,
	&qos_setting->npu_qos_req_npu);
	npu_info("%s() npu_qos_rate(%d)\n", __func__, cur_value);

	return 0;
	}


	s32 __update_freq_from_showcase(__u32 nCategory)
	{
	s32 nValue = 0;
	struct list_head pos, q;
	struct npu_session_qos_req *qr;

	list_for_each_safe(pos, q, &qos_list) {
	qr = list_entry(pos, struct npu_session_qos_req, list);
	if (qr->eCategory == nCategory) {
	nValue = qr->req_freq > nValue ? qr->req_freq : nValue;
	npu_dbg("[U%u]Candidate Freq. category : %u freq : %d\n",
	qr->sessionUID, nCategory, nValue);
	}
	}

	return nValue;
	}

	int __req_param_qos(int uid, __u32 nCategory, struct pm_qos_request *req, s32 new_value)
	{
	int ret = 0;
	s32 cur_value, rec_value;
	struct list_head pos, q;
	struct npu_session_qos_req *qr;

	//Check that same uid, and category whether already registered.
	list_for_each_safe(pos, q, &qos_list) {
	qr = list_entry(pos, struct npu_session_qos_req, list);
	if ((qr->sessionUID == uid) && (qr->eCategory == nCategory)) {
	cur_value = qr->req_freq;
	npu_dbg("[U%u]Change Req Freq. category : %u, from freq : %d to %d\n",
	uid, nCategory, cur_value, new_value);
	list_del(pos);
	qr->sessionUID = uid;
	qr->req_freq = new_value;
	qr->eCategory = nCategory;
	list_add_tail(&qr->list, &qos_list);
	rec_value = __update_freq_from_showcase(nCategory);

	if (new_value > rec_value) {
	pm_qos_update_request(req, new_value);
	npu_dbg("[U%u]Changed Freq. category : %u, from freq : %d to %d\n",
	uid, nCategory, cur_value, new_value);
	} else {
	pm_qos_update_request(req, rec_value);
	npu_dbg("[U%u]Recovered Freq. category : %u, from freq : %d to %d\n",
	uid, nCategory, cur_value, rec_value);
	}
	return ret;
	}
	}
	//No Same uid, and category. Add new item
	qr = kmalloc(sizeof(struct npu_session_qos_req), GFP_KERNEL);
	if (!qr) {
	npu_err("memory alloc fail.\n");
	return -ENOMEM;
	}
	qr->sessionUID = uid;
	qr->req_freq = new_value;
	qr->eCategory = nCategory;
	list_add_tail(&qr->list, &qos_list);

	//If new_value is lager than current value, update the freq
	cur_value = (s32)pm_qos_read_req_value(req->pm_qos_class, req);
	npu_dbg("[U%u]New Freq. category : %u freq : %u\n",
	qr->sessionUID, qr->eCategory, qr->req_freq);
	if (cur_value < new_value) {
	npu_dbg("[U%u]Update Freq. category : %u freq : %u\n",
	qr->sessionUID, qr->eCategory, qr->req_freq);
	pm_qos_update_request(req, new_value);
	}
	return ret;
	}

	npu_s_param_ret npu_qos_param_handler(struct npu_session sess, struct vs4l_param param, int *retval)
	{
	BUG_ON(!sess);
	BUG_ON(!param);

	mutex_lock(&qos_setting->npu_qos_lock);

	switch (param->target) {
	case NPU_S_PARAM_QOS_NPU:
	qos_setting->req_npu_freq = param->offset;
	//Set minimum safe clock as default to avoid NDONE
	if (qos_setting->req_npu_freq < qos_setting->default_freq)
	qos_setting->req_npu_freq = qos_setting->default_freq;
	__req_param_qos(sess->uid, param->target, &qos_setting->npu_qos_req_npu, qos_setting->req_npu_freq);

	mutex_unlock(&qos_setting->npu_qos_lock);
	return S_PARAM_HANDLED;
	case NPU_S_PARAM_QOS_MIF:
	qos_setting->req_mif_freq = param->offset;
	__req_param_qos(sess->uid, param->target, &qos_setting->npu_qos_req_mif, qos_setting->req_mif_freq);

	mutex_unlock(&qos_setting->npu_qos_lock);
	return S_PARAM_HANDLED;
	case NPU_S_PARAM_QOS_INT:
	qos_setting->req_int_freq = param->offset;
	__req_param_qos(sess->uid, param->target, &qos_setting->npu_qos_req_int, qos_setting->req_int_freq);

	mutex_unlock(&qos_setting->npu_qos_lock);
	return S_PARAM_HANDLED;
	case NPU_S_PARAM_QOS_CL0:
	qos_setting->req_cl0_freq = param->offset;
	__req_param_qos(sess->uid, param->target, &qos_setting->npu_qos_req_cpu_cl0, qos_setting->req_cl0_freq);

	mutex_unlock(&qos_setting->npu_qos_lock);
	return S_PARAM_HANDLED;
	case NPU_S_PARAM_QOS_CL1:
	qos_setting->req_cl1_freq = param->offset;
	__req_param_qos(sess->uid, param->target, &qos_setting->npu_qos_req_cpu_cl1, qos_setting->req_cl1_freq);

	mutex_unlock(&qos_setting->npu_qos_lock);
	return S_PARAM_HANDLED;
	case NPU_S_PARAM_QOS_CL2:
	qos_setting->req_cl2_freq = param->offset;
	__req_param_qos(sess->uid, param->target, &qos_setting->npu_qos_req_cpu_cl2, qos_setting->req_cl2_freq);

	mutex_unlock(&qos_setting->npu_qos_lock);
	return S_PARAM_HANDLED;
	case NPU_S_PARAM_CPU_AFF:
	case NPU_S_PARAM_QOS_RST:
	default:
	mutex_unlock(&qos_setting->npu_qos_lock);
	return S_PARAM_NOMB;
	}
	}