antifallobst
/
lineage_kernel_xcoverpro
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
lineage_kernel_xcoverpro/include/linux/input/input_booster.h

689 lines
28 KiB
C
Raw Normal View History

initial commit
2023-06-18 22:53:49 +00:00
#if !defined(CONFIG_INPUT_BOOSTER) // Input Booster +
#ifndef _INPUT_BOOSTER_H_
#define _INPUT_BOOSTER_H_
#include <linux/pm_qos.h>
#include <linux/of.h>
#include <linux/ems_service.h>
#ifdef CONFIG_SCHED_HMP
#define USE_HMP_BOOST
#elif defined CONFIG_SCHED_EMS
#define USE_EHMP_BOOST
#endif
#define pr_booster(format, ...) { \
if (debug_flag) \
printk(format, ## __VA_ARGS__); \
}
#define MAX_MULTI_TOUCH_EVENTS 3
#define MAX_EVENTS (MAX_MULTI_TOUCH_EVENTS * 10)
#define INPUT_BOOSTER_NULL 0
#define INIT_ZERO 0
#define HEADGAGE "******"
#define TAILGAGE "**** "
#define set_qos(req, pm_qos_class, value) { \
if (value) { \
if (pm_qos_request_active(req)) {\
pr_booster("[Input Booster2] %s pm_qos_update_request : %d\n", glGage, value); \
pm_qos_update_request(req, value); \
} else { \
pr_booster("[Input Booster2] %s pm_qos_add_request : %d\n", glGage, value); \
pm_qos_add_request(req, pm_qos_class, value); \
} \
} else { \
pr_booster("[Input Booster2] %s remove_qos\n", glGage); \
remove_qos(req); \
} \
}
#define set_qos_dma_latency(req, pm_qos_class, value) { \
if(!value){ \
if (pm_qos_request_active(req)) {\
pr_booster("[Input Booster2] %s pm_qos_dma_latency_update_request : %d\n", glGage, value); \
pm_qos_update_request(req, value); \
} else { \
pr_booster("[Input Booster2] %s pm_qos_dma_latency_add_request : %d\n", glGage, value); \
pm_qos_add_request(req, pm_qos_class, value); \
} \
} else { \
pr_booster("[Input Booster2] %s remove_qos_dma_latency\n", glGage); \
remove_qos(req); \
} \
}
#define remove_qos(req) { \
if (pm_qos_request_active(req)) \
pm_qos_remove_request(req); \
}
#ifdef USE_HMP_BOOST
#define set_hmp(enable) { \
if (enable != current_hmp_boost) { \
pr_booster("[Input Booster2] ****** set_hmp : %d ( %s )\n", enable, __FUNCTION__); \
if (set_hmp_boost(enable) < 0) { \
pr_booster("[Input Booster2] ****** !!! fail to HMP !!!\n"); \
} \
current_hmp_boost = enable; \
} \
}
#elif defined USE_EHMP_BOOST
#include <linux/ems.h>
static DEFINE_MUTEX(input_lock);
int hmp_boost_value = INIT_ZERO;
static struct kpp kpp_ta;
static struct kpp kpp_fg;
#define set_hmp(enable) { \
mutex_lock(&input_lock); \
if (enable != current_hmp_boost) { \
if (hmp_boost_value <= 0 && !enable) { \
pr_booster("[Input Booster2] ****** ERROR : set_ehmp unexpected disable request happened ( %s )\n", __FUNCTION__); \
} else if (hmp_boost_value >= 1 && enable) { \
pr_booster("[Input Booster2] ****** ERROR : set_ehmp unexpected enable request happened ( %s )\n", __FUNCTION__); \
} else { \
pr_booster("[Input Booster2] ****** set_ehmp : %d ( %s )\n", enable, __FUNCTION__); \
if (enable) { \
hmp_boost_value++; \
kpp_request(STUNE_TOPAPP, &kpp_ta, 1); \
kpp_request(STUNE_FOREGROUND, &kpp_fg, 1); \
} else { \
hmp_boost_value--; \
kpp_request(STUNE_TOPAPP, &kpp_ta, 0); \
kpp_request(STUNE_FOREGROUND, &kpp_fg, 0); \
} \
current_hmp_boost = enable; \
} \
} \
mutex_unlock(&input_lock); \
}
#else
#define set_hmp(enable)
#endif
#if defined(CONFIG_ARCH_EXYNOS) //______________________________________________________________________________
#define SET_BOOSTER { \
int value = INPUT_BOOSTER_NULL; \
_this->level++; \
MAX_T_INPUT_BOOSTER(value, hmp_boost); \
if (value == INPUT_BOOSTER_NULL) { \
value = 0; \
} \
set_hmp(value); \
set_qos(&_this->cpu_qos, PM_QOS_CLUSTER1_FREQ_MIN/*PM_QOS_CPU_FREQ_MIN*/, _this->param[_this->index].cpu_freq); \
set_qos(&_this->kfc_qos, PM_QOS_CLUSTER0_FREQ_MIN/*PM_QOS_KFC_FREQ_MIN*/, _this->param[_this->index].kfc_freq); \
set_qos(&_this->mif_qos, PM_QOS_BUS_THROUGHPUT, _this->param[_this->index].mif_freq); \
set_qos(&_this->int_qos, PM_QOS_DEVICE_THROUGHPUT, _this->param[_this->index].int_freq); \
set_qos_dma_latency(&_this->dms_latency_qos, PM_QOS_CPU_DMA_LATENCY, _this->param[_this->index].dma_latency); \
}
#define REMOVE_BOOSTER { \
int value = INPUT_BOOSTER_NULL; \
_this->level = -1; \
MAX_T_INPUT_BOOSTER(value, hmp_boost); \
if (value == INPUT_BOOSTER_NULL) { \
value = 0; \
} \
set_hmp(value); \
remove_qos(&_this->cpu_qos); \
remove_qos(&_this->kfc_qos); \
remove_qos(&_this->mif_qos); \
remove_qos(&_this->int_qos); \
remove_qos(&_this->dms_latency_qos); \
}
#define PROPERTY_BOOSTER(_device_param_, _dt_param_, _time_) { \
_device_param_.cpu_freq = _dt_param_.cpu_freq; \
_device_param_.kfc_freq = _dt_param_.kfc_freq; \
_device_param_.mif_freq = _dt_param_.mif_freq; \
_device_param_.int_freq = _dt_param_.int_freq; \
_device_param_.time = _dt_param_._time_; \
_device_param_.hmp_boost = _dt_param_.hmp_boost; \
_device_param_.dma_latency = _dt_param_.dma_latency; \
}
#endif //______________________________________________________________________________
#define GET_BOOSTER_PARAM(_GENDER_, _HEAD_PARAM_, _TAIL_PARAM_) { \
int levels[][3] = { \
{1, 2, 0}, \
{2, 2, 3}, \
{3, 1, 1}, \
{4, 1, 2} }; \
int j, k; \
for (j = 0; j < (int)(sizeof(levels)/(3*sizeof(int))); j++) {\
if ((_GENDER_->pDT->nlevels > 2 && levels[j][0] == _GENDER_->level) || (_GENDER_->pDT->nlevels == 1 && j == 2) || (_GENDER_->pDT->nlevels == 2 && j == 3)) { \
if (levels[j][1] > 0) { \
for (k = 0; k < _GENDER_->pDT->nlevels; k++) { \
if (levels[j][1] == _GENDER_->pDT->param_tables[k].ilevels) { \
_HEAD_PARAM_ = (_GENDER_->pDT->param_tables[k].head_time > 0) ? &_GENDER_->pDT->param_tables[k] : NULL; \
break; \
} \
} \
} \
if (levels[j][2] > 0) { \
for (k = 0; k < dt_gender->pDT->nlevels; k++) { \
if (levels[j][2] == dt_gender->pDT->param_tables[k].ilevels) { \
_TAIL_PARAM_ = &_GENDER_->pDT->param_tables[k]; \
break; \
} \
} \
} \
break; \
} \
} \
}
#define CHANGE_BOOSTER { \
struct t_input_booster_device_tree_param *head_param = NULL, *tail_param = NULL; \
GET_BOOSTER_PARAM(dt_gender, head_param, tail_param) \
memset(dt_gender->pBooster->param, 0x00, sizeof(struct t_input_booster_param)*2); \
if (head_param != NULL) { \
PROPERTY_BOOSTER(dt_gender->pBooster->param[0], (*head_param), head_time) \
} \
if (tail_param != NULL) { \
PROPERTY_BOOSTER(dt_gender->pBooster->param[1], (*tail_param), tail_time) \
} \
}
#define INIT_BOOSTER(_DEVICE_) { \
_DEVICE_##_booster.input_booster_state = input_booster_idle_state; \
INIT_DELAYED_WORK(&_DEVICE_##_booster.input_booster_timeout_work[0], TIMEOUT_FUNC(_DEVICE_)); \
INIT_DELAYED_WORK(&_DEVICE_##_booster.input_booster_timeout_work[1], TIMEOUT_FUNC(_DEVICE_)); \
INIT_WORK(&_DEVICE_##_booster.input_booster_set_booster_work, SET_BOOSTER_FUNC(_DEVICE_)); \
INIT_WORK(&_DEVICE_##_booster.input_booster_reset_booster_work, RESET_BOOSTER_FUNC(_DEVICE_)); \
mutex_init(&_DEVICE_##_booster.lock); \
_DEVICE_##_booster.change_on_release = 0; \
_DEVICE_##_booster.multi_events = 0; \
{ \
int i; \
for (i = 0; i < sizeof(_DEVICE_##_booster.param)/sizeof(struct t_input_booster_param); i++) { \
_DEVICE_##_booster.level = -1; \
} \
for (i = 0; i < ndevice_in_dt; i++) { \
if (device_tree_infor[i].type == _DEVICE_##_booster_dt.type) { \
struct t_input_booster_device_tree_gender *dt_gender = &_DEVICE_##_booster_dt; \
dt_gender->pDT = &device_tree_infor[i]; \
dt_gender->pBooster = &_DEVICE_##_booster; \
CHANGE_BOOSTER \
break; \
} \
} \
} \
}
#define TIMEOUT_FUNC(_DEVICE_) input_booster_##_DEVICE_##_timeout_work_func
#define DECLARE_TIMEOUT_FUNC(_DEVICE_) \
static void input_booster_##_DEVICE_##_timeout_work_func(struct work_struct *work) \
{ \
struct t_input_booster *_this = &_DEVICE_##_booster; \
int param_max = sizeof(_this->param)/sizeof(struct t_input_booster_param), temp_index = -1; \
mutex_lock(&_this->lock); \
pr_booster("[Input Booster] %s Timeout : changed index : %d (%s)\n", HEADGAGE, _this->index, __FUNCTION__); \
if (_this->index >= 2 && delayed_work_pending(&_this->input_booster_timeout_work[_this->index-2])) { \
mutex_unlock(&_this->lock); \
return; \
} \
if (_this->index == param_max && delayed_work_pending(&_this->input_booster_timeout_work[_this->index-1])) { \
temp_index = _this->index; \
_this->index = (_this->index) ? _this->index-1 : 0; \
} \
pr_booster("[Input Booster] %s Timeout : changed index : %d (%s)\n", HEADGAGE, _this->index, __FUNCTION__); \
if (_this->index < param_max) { \
pr_booster("[Input Booster] %s Timeout : changed index : %d, time : %d (%s)\n", HEADGAGE, _this->index, _this->param[_this->index].time, __FUNCTION__); \
pr_booster("[Input Booster] %s hmp : %d dma_latency : %d cpu : %d (%s)\n", TAILGAGE, _this->param[_this->index].hmp_boost, _this->param[_this->index].dma_latency, _this->param[_this->index].cpu_freq, __FUNCTION__); \
if (_this->param[(_this->index) ? _this->index-1 : 0].time > 0) { \
SET_BOOSTER; \
if (_this->change_on_release) { \
schedule_delayed_work(&_this->input_booster_timeout_work[_this->index], msecs_to_jiffies(_this->param[_this->index].time)); \
_this->index++; \
CHANGE_STATE_TO(idle); \
} \
} \
_this->index = (temp_index >= 0) ? temp_index : _this->index; \
} else { \
pr_booster("[Input Booster] Timeout : completed param_max : %d (%s)\n", param_max, __FUNCTION__); \
pr_booster("[Input Booster]\n"); \
REMOVE_BOOSTER; \
_this->index = 0; \
_this->multi_events = (_this->multi_events > 0) ? 0 : _this->multi_events; \
CHANGE_STATE_TO(idle); \
} \
mutex_unlock(&_this->lock); \
}
#define SET_BOOSTER_FUNC(_DEVICE_) input_booster_##_DEVICE_##_set_booster_work_func
#define DECLARE_SET_BOOSTER_FUNC(_DEVICE_) \
static void input_booster_##_DEVICE_##_set_booster_work_func(struct work_struct *work) \
{ \
struct t_input_booster *_this = (struct t_input_booster *)(&_DEVICE_##_booster); \
mutex_lock(&_this->lock); \
_this->input_booster_state(_this, _this->event_type); \
mutex_unlock(&_this->lock); \
}
#define RESET_BOOSTER_FUNC(_DEVICE_) input_booster_##_DEVICE_##_reset_booster_work_func
#define DECLARE_RESET_BOOSTER_FUNC(_DEVICE_) \
static void input_booster_##_DEVICE_##_reset_booster_work_func(struct work_struct *work) \
{ \
struct t_input_booster *_this = (struct t_input_booster *)(&_DEVICE_##_booster); \
int i; \
mutex_lock(&_this->lock); \
_this->multi_events = 0; \
_this->index = 0; \
for (i = 0; i < 2; i++) { \
if (delayed_work_pending(&_this->input_booster_timeout_work[i])) { \
pr_booster("[Input Booster] **** cancel the pending workqueue for reset\n"); \
cancel_delayed_work(&_this->input_booster_timeout_work[i]); \
} \
} \
CHANGE_STATE_TO(idle); \
REMOVE_BOOSTER; \
mutex_unlock(&_this->lock); \
}
#define DECLARE_STATE_FUNC(_STATE_) void input_booster_##_STATE_##_state(void *__this, int input_booster_event)
#define CHANGE_STATE_TO(_STATE_) {_this->input_booster_state = input_booster_##_STATE_##_state; }
#define RUN_BOOSTER(_DEVICE_, _EVENT_) { \
if (_DEVICE_##_booster_dt.level > 0) { \
_DEVICE_##_booster.event_type = _EVENT_; \
(_EVENT_ == BOOSTER_ON) ? _DEVICE_##_booster.multi_events++ : _DEVICE_##_booster.multi_events--; \
schedule_work(&_DEVICE_##_booster.input_booster_set_booster_work); \
} \
}
//+++++++++++++++++++++++++++++++++++++++++++++++ STRUCT & VARIABLE FOR SYSFS +++++++++++++++++++++++++++++++++++++++++++++++//
#define SYSFS_CLASS(_ATTR_, _ARGU_, _COUNT_) \
static ssize_t input_booster_sysfs_class_show_##_ATTR_(struct class *dev, struct class_attribute *attr, char *buf) \
{ \
struct t_input_booster_device_tree_gender *dt_gender = &touch_booster_dt; \
ssize_t ret; int level; \
unsigned int debug_level = 0, cpu_freq = 0, kfc_freq = 0, mif_freq = 0, int_freq = 0, hmp_boost = 0, dma_latency = 0, head_time = 0, tail_time = 0; \
struct t_input_booster_device_tree_param *head_param = NULL, *tail_param = NULL; \
GET_BOOSTER_PARAM(dt_gender, head_param, tail_param) \
debug_level = debug_flag; \
level = dt_gender->level; \
if (strcmp(#_ATTR_, "head") == 0 && head_param != NULL) { \
cpu_freq = head_param->cpu_freq; \
kfc_freq = head_param->kfc_freq; \
mif_freq = head_param->mif_freq; \
int_freq = head_param->int_freq; \
hmp_boost = head_param->hmp_boost; \
dma_latency = head_param->dma_latency; \
head_time = head_param->head_time; \
tail_time = head_param->tail_time; \
} \
if (strcmp(#_ATTR_, "tail") == 0 && tail_param != NULL) { \
cpu_freq = tail_param->cpu_freq; \
kfc_freq = tail_param->kfc_freq; \
mif_freq = tail_param->mif_freq; \
int_freq = tail_param->int_freq; \
hmp_boost = tail_param->hmp_boost; \
dma_latency = tail_param->dma_latency; \
head_time = tail_param->head_time; \
tail_time = tail_param->tail_time; \
} \
ret = sprintf _ARGU_; \
pr_booster("[Input Booster8] %s buf : %s\n", __FUNCTION__, buf); \
return ret; \
} \
static ssize_t input_booster_sysfs_class_store_##_ATTR_(struct class *dev, struct class_attribute *attr, const char *buf, size_t count) \
{ \
struct t_input_booster_device_tree_gender *dt_gender = &touch_booster_dt; \
int level[1] = {-1}, len; \
unsigned int debug_level[1] = {-1}, cpu_freq[1] = {-1}, kfc_freq[1] = {-1}, mif_freq[1] = {-1}, int_freq[1] = {-1}, hmp_boost[1] = {-1}, dma_latency[1] = {-1}, head_time[1] = {-1}, tail_time[1] = {-1}; \
struct t_input_booster_device_tree_param *head_param = NULL, *tail_param = NULL; \
GET_BOOSTER_PARAM(dt_gender, head_param, tail_param) \
len = sscanf _ARGU_; \
pr_booster("[Input Booster8] %s buf : %s\n", __FUNCTION__, buf); \
if (sscanf _ARGU_ != _COUNT_) { \
return count; \
} \
debug_flag = (*debug_level == (unsigned int)(-1)) ? debug_flag : *debug_level; \
dt_gender->level = (*level == (unsigned int)(-1)) ? dt_gender->level : *level; \
if (*head_time != (unsigned int)(-1) && head_param != NULL) { \
head_param->cpu_freq = (*cpu_freq == (unsigned int)(-1)) ? head_param->cpu_freq : *cpu_freq; \
head_param->kfc_freq = (*kfc_freq == (unsigned int)(-1)) ? head_param->kfc_freq : *kfc_freq; \
head_param->mif_freq = (*mif_freq == (unsigned int)(-1)) ? head_param->mif_freq : *mif_freq; \
head_param->int_freq = (*int_freq == (unsigned int)(-1)) ? head_param->int_freq : *int_freq; \
head_param->hmp_boost = (*hmp_boost == (unsigned int)(-1)) ? head_param->hmp_boost : *hmp_boost; \
head_param->dma_latency = (*dma_latency == (unsigned int)(-1)) ? head_param->dma_latency : *dma_latency; \
head_param->head_time = (*head_time == (unsigned int)(-1)) ? head_param->head_time : *head_time; \
head_param->tail_time = (*tail_time == (unsigned int)(-1)) ? head_param->tail_time : *tail_time; \
} \
if (*tail_time != (unsigned int)(-1) && tail_param != NULL) { \
tail_param->cpu_freq = (*cpu_freq == (unsigned int)(-1)) ? tail_param->cpu_freq : *cpu_freq; \
tail_param->kfc_freq = (*kfc_freq == (unsigned int)(-1)) ? tail_param->kfc_freq : *kfc_freq; \
tail_param->mif_freq = (*mif_freq == (unsigned int)(-1)) ? tail_param->mif_freq : *mif_freq; \
tail_param->int_freq = (*int_freq == (unsigned int)(-1)) ? tail_param->int_freq : *int_freq; \
tail_param->hmp_boost = (*hmp_boost == (unsigned int)(-1)) ? tail_param->hmp_boost : *hmp_boost; \
tail_param->dma_latency = (*dma_latency == (unsigned int)(-1)) ? tail_param->dma_latency : *dma_latency; \
tail_param->head_time = (*head_time == (unsigned int)(-1)) ? tail_param->head_time : *head_time; \
tail_param->tail_time = (*tail_time == (unsigned int)(-1)) ? tail_param->tail_time : *tail_time; \
} \
CHANGE_BOOSTER \
return count; \
} \
static struct class_attribute class_attr_##_ATTR_ = __ATTR(_ATTR_, S_IRUGO | S_IWUSR, input_booster_sysfs_class_show_##_ATTR_, input_booster_sysfs_class_store_##_ATTR_);
#define SYSFS_DEVICE(_ATTR_, _ARGU_, _COUNT_) \
static ssize_t input_booster_sysfs_device_show_##_ATTR_(struct device *dev, struct device_attribute *attr, char *buf) \
{ \
struct t_input_booster_device_tree_gender *dt_gender = dev_get_drvdata(dev); \
ssize_t ret = 0; \
int level, Arg_count = _COUNT_; \
unsigned int cpu_freq, kfc_freq, mif_freq, int_freq, hmp_boost, dma_latency, head_time, tail_time, phase_time; \
struct t_input_booster_device_tree_param *head_param = NULL, *tail_param = NULL; \
if (dt_gender == NULL) { \
return ret; \
} \
GET_BOOSTER_PARAM(dt_gender, head_param, tail_param) \
if (Arg_count == 1) { \
level = dt_gender->level; \
ret = sprintf _ARGU_; \
pr_booster("[Input Booster8] %s buf : %s\n", __FUNCTION__, buf); \
} else { \
if (head_param != NULL) { \
level = head_param->ilevels; \
cpu_freq = head_param->cpu_freq; \
kfc_freq = head_param->kfc_freq; \
mif_freq = head_param->mif_freq; \
int_freq = head_param->int_freq; \
hmp_boost = head_param->hmp_boost; \
dma_latency = head_param->dma_latency; \
head_time = head_param->head_time; \
tail_time = head_param->tail_time; \
phase_time = head_param->phase_time; \
ret = sprintf _ARGU_; \
buf = buf + ret - 1; \
} \
*buf = '|'; \
*(buf+1) = '\n';\
if (tail_param != NULL) { \
buf = buf + 1; \
level = tail_param->ilevels; \
cpu_freq = tail_param->cpu_freq; \
kfc_freq = tail_param->kfc_freq; \
mif_freq = tail_param->mif_freq; \
int_freq = tail_param->int_freq; \
hmp_boost = tail_param->hmp_boost; \
dma_latency = tail_param->dma_latency; \
head_time = tail_param->head_time; \
tail_time = tail_param->tail_time; \
phase_time = tail_param->phase_time; \
ret += sprintf _ARGU_; \
} \
pr_booster("[Input Booster8] %s buf : %s\n", __FUNCTION__, buf); \
} \
return ret; \
} \
static ssize_t input_booster_sysfs_device_store_##_ATTR_(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
{ \
struct t_input_booster_device_tree_gender *dt_gender = dev_get_drvdata(dev); \
struct t_input_booster_device_tree_infor *dt_infor = (dt_gender) ? dt_gender->pDT : NULL; \
int level[1] = {-1}, len; \
unsigned int cpu_freq[1] = {-1}, kfc_freq[1] = {-1}, mif_freq[1] = {-1}, int_freq[1] = {-1}, hmp_boost[1] = {-1}, dma_latency[1] = {-1}, head_time[1] = {-1}, tail_time[1] = {-1}, phase_time[1] = {-1}; \
len = sscanf _ARGU_; \
pr_booster("[Input Booster8] %s buf : %s\n", __FUNCTION__, buf); \
if (dt_infor == NULL) { \
return count; \
} \
if (len != _COUNT_) { \
pr_booster("### Keep this format : [level cpu_freq kfc_freq mif_freq int_freq hmp_boost dma_latency] (Ex: 1 1600000 0 1500000 667000 333000 1###\n"); \
pr_booster("### Keep this format : [level head_time tail_time phase_time] (Ex: 1 130 500 50 ###\n"); \
pr_booster("### Keep this format : [type value] (Ex: 2 1 ###\n"); \
return count; \
} \
if (level[0] >= 0) { \
int Arg_count = _COUNT_; \
if (Arg_count == 1) { \
dt_gender->level = level[0]; \
} else { \
int k; \
for (k = 0; k < dt_infor->nlevels; k++) { \
if (level[0] == dt_infor->param_tables[k].ilevels) { \
dt_infor->param_tables[k].cpu_freq = (*cpu_freq == (unsigned int)(-1)) ? dt_infor->param_tables[k].cpu_freq : *cpu_freq; \
dt_infor->param_tables[k].kfc_freq = (*kfc_freq == (unsigned int)(-1)) ? dt_infor->param_tables[k].kfc_freq : *kfc_freq; \
dt_infor->param_tables[k].mif_freq = (*mif_freq == (unsigned int)(-1)) ? dt_infor->param_tables[k].mif_freq : *mif_freq; \
dt_infor->param_tables[k].int_freq = (*int_freq == (unsigned int)(-1)) ? dt_infor->param_tables[k].int_freq : *int_freq; \
dt_infor->param_tables[k].hmp_boost = (*hmp_boost == (unsigned int)(-1)) ? dt_infor->param_tables[k].hmp_boost : *hmp_boost; \
dt_infor->param_tables[k].dma_latency = (*dma_latency == (unsigned int)(-1)) ? dt_infor->param_tables[k].dma_latency : *dma_latency; \
dt_infor->param_tables[k].head_time = (*head_time == (unsigned int)(-1)) ? dt_infor->param_tables[k].head_time : *head_time; \
dt_infor->param_tables[k].tail_time = (*tail_time == (unsigned int)(-1)) ? dt_infor->param_tables[k].tail_time : *tail_time; \
dt_infor->param_tables[k].phase_time = (*phase_time == (unsigned int)(-1)) ? dt_infor->param_tables[k].phase_time : *phase_time; \
pr_booster("[Input Booster8] %s time : %d %d %d\n", __FUNCTION__, dt_infor->param_tables[*level].head_time, dt_infor->param_tables[k].tail_time, dt_infor->param_tables[*level].phase_time); \
} \
} \
} \
CHANGE_BOOSTER \
} \
return count; \
} \
static DEVICE_ATTR(_ATTR_, S_IRUGO | S_IWUSR, input_booster_sysfs_device_show_##_ATTR_, input_booster_sysfs_device_store_##_ATTR_);
#define INIT_SYSFS_CLASS(_CLASS_) { \
int ret = class_create_file(sysfs_class, &class_attr_##_CLASS_); \
if (ret) { \
pr_booster("[Input Booster] Failed to create class\n"); \
class_destroy(sysfs_class); \
return; \
} \
}
#define INIT_SYSFS_DEVICE(_DEVICE_) { \
struct device *sysfs_dev; int ret = 0;\
sysfs_dev = device_create(sysfs_class, NULL, 0, &_DEVICE_##_booster_dt, #_DEVICE_); \
if (IS_ERR(sysfs_dev)) { \
ret = IS_ERR(sysfs_dev); \
pr_booster("[Input Booster] Failed to create %s sysfs device[%d]\n", #_DEVICE_, ret); \
return; \
} \
ret = sysfs_create_group(&sysfs_dev->kobj, &dvfs_attr_group); \
if (ret) { \
pr_booster("[Input Booster] Failed to create %s sysfs group\n", #_DEVICE_); \
return; \
} \
}
//----------------------------------------------- STRUCT & VARIABLE FOR SYSFS -----------------------------------------------//
enum booster_mode_on_off {
BOOSTER_OFF = 0,
BOOSTER_ON,
};
struct input_value input_events[MAX_EVENTS+1];
struct t_input_booster_param {
u32 cpu_freq;
u32 kfc_freq;
u32 mif_freq;
u32 int_freq;
u16 time;
u8 hmp_boost;
u32 dma_latency;
u8 dummy;
};
struct t_input_booster {
struct mutex lock;
struct t_input_booster_param param[2];
struct pm_qos_request cpu_qos;
struct pm_qos_request kfc_qos;
struct pm_qos_request mif_qos;
struct pm_qos_request int_qos;
struct pm_qos_request dms_latency_qos;
struct delayed_work input_booster_timeout_work[2];
struct work_struct input_booster_set_booster_work;
struct work_struct input_booster_reset_booster_work;
int index;
int multi_events;
int event_type;
int change_on_release;
int level;
void (*input_booster_state)(void *__this, int input_booster_event);
};
//+++++++++++++++++++++++++++++++++++++++++++++++ STRUCT & VARIABLE FOR DEVICE TREE +++++++++++++++++++++++++++++++++++++++++++++++//
struct t_input_booster_device_tree_param {
u8 ilevels;
u8 hmp_boost;
u32 dma_latency;
u16 head_time;
u16 tail_time;
u16 phase_time;
u32 cpu_freq;
u32 kfc_freq;
u32 mif_freq;
u32 int_freq;
};
struct t_input_booster_device_tree_infor {
const char *label;
int type;
int nlevels;
struct t_input_booster_device_tree_param *param_tables;
};
struct t_input_booster_device_tree_gender {
int type;
int level;
struct t_input_booster *pBooster;
struct t_input_booster_device_tree_infor *pDT;
};
//______________________________________________________________________________ <<< in DTSI file >>>
//______________________________________________________________________________ input_booster,type = <4>; /* BOOSTER_DEVICE_KEYBOARD */
//______________________________________________________________________________
struct t_input_booster_device_tree_gender key_booster_dt = {0, 1,}; // type : 0, level : 1
struct t_input_booster_device_tree_gender touchkey_booster_dt = {1, 1,}; // type : 1, level : 1
struct t_input_booster_device_tree_gender touch_booster_dt = {2, 2,}; // type : 2, level : 2
struct t_input_booster_device_tree_gender multitouch_booster_dt = {3, 1,}; // type : 3, level : 1
struct t_input_booster_device_tree_gender keyboard_booster_dt = {4, 1,}; // type : 4, level : 1
struct t_input_booster_device_tree_gender mouse_booster_dt = {5, 1,}; // type : 5, level : 1
struct t_input_booster_device_tree_gender mouse_wheel_booster_dt = {6, 1,}; // type : 6, level : 1
struct t_input_booster_device_tree_gender hover_booster_dt = {7, 1,}; // type : 7, level : 1
struct t_input_booster_device_tree_gender pen_booster_dt = {8, 1,}; // type : 8, level : 1
struct t_input_booster_device_tree_gender key_two_booster_dt = {9, 1,}; // type : 9, level : 1
struct t_input_booster_device_tree_infor *device_tree_infor;
int ndevice_in_dt;
//---------------------------------------------- STRUCT & VARIABLE FOR DEVICE TREE ----------------------------------------------//
//+++++++++++++++++++++++++++++++++++++++++++++++ STRUCT & VARIABLE FOR SYSFS +++++++++++++++++++++++++++++++++++++++++++++++//
unsigned int debug_flag = INIT_ZERO;
SYSFS_CLASS(debug_level, (buf, "%u\n", debug_level), 1)
SYSFS_CLASS(head, (buf, "%d %u %u %u %u %u %u\n", head_time, cpu_freq, kfc_freq, mif_freq, int_freq, hmp_boost, dma_latency), 7)
SYSFS_CLASS(tail, (buf, "%d %u %u %u %u %u %u\n", tail_time, cpu_freq, kfc_freq, mif_freq, int_freq, hmp_boost, dma_latency), 7)
SYSFS_CLASS(level, (buf, "%d\n", level), 1)
SYSFS_DEVICE(level, (buf, "%d\n", level), 1)
SYSFS_DEVICE(freq, (buf, "%d %u %u %u %u %u %u\n", level, cpu_freq, kfc_freq, mif_freq, int_freq, hmp_boost, dma_latency), 7)
SYSFS_DEVICE(time, (buf, "%d %u %u %u\n", level, head_time, tail_time, phase_time), 4)
static ssize_t input_booster_sysfs_device_store_control(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
struct t_input_booster_device_tree_gender *dt_gender = dev_get_drvdata(dev);
struct t_input_booster *dt_booster = (dt_gender) ? dt_gender->pBooster : NULL;
int value;
unsigned int type;
if (dt_booster == NULL) {
return count;
}
if (sscanf(buf, "%u %d", &type, &value) != 2) {
pr_booster("### Keep this format : [type value] (Ex: 2 1 ###\n");
return count;
}
dt_booster->event_type = value;
schedule_work(&dt_booster->input_booster_set_booster_work);
return count;
}
static DEVICE_ATTR(control, S_IRUGO | S_IWUSR, NULL, input_booster_sysfs_device_store_control);
static struct attribute *dvfs_attributes[] = {
&dev_attr_level.attr,
&dev_attr_freq.attr,
&dev_attr_time.attr,
&dev_attr_control.attr,
NULL,
};
static struct attribute_group dvfs_attr_group = {
.attrs = dvfs_attributes,
};
//---------------------------------------------- STRUCT & VARIABLE FOR SYSFS ----------------------------------------------//
int TouchIDs[MAX_MULTI_TOUCH_EVENTS];
char *glGage = HEADGAGE;
bool current_hmp_boost = INIT_ZERO;
struct t_input_booster touch_booster;
struct t_input_booster multitouch_booster;
struct t_input_booster key_booster;
struct t_input_booster touchkey_booster;
struct t_input_booster keyboard_booster;
struct t_input_booster mouse_booster;
struct t_input_booster mouse_wheel_booster;
struct t_input_booster pen_booster;
struct t_input_booster hover_booster;
struct t_input_booster key_two_booster;
struct t_input_booster *t_input_boosters[] = {
&touch_booster,
&multitouch_booster,
&key_booster,
&touchkey_booster,
&keyboard_booster,
&mouse_booster,
&mouse_wheel_booster,
&pen_booster,
&hover_booster,
&key_two_booster
};
#define MAX_T_INPUT_BOOSTER(ref, _PARAM_) { \
size_t i = 0; \
int max = INPUT_BOOSTER_NULL; \
for (i = 0; i < sizeof(t_input_boosters)/sizeof(struct t_input_booster *); i++) { \
if (t_input_boosters[i]->level >= 0 && t_input_boosters[i]->level < (int)(sizeof(t_input_boosters[i]->param)/sizeof(struct t_input_booster_param))) { \
pr_booster("[Input Booster3] %s booster type : %lu level : %d value : %d\n", #_PARAM_, i, t_input_boosters[i]->level, t_input_boosters[i]->param[t_input_boosters[i]->level]._PARAM_); \
if (max < (int)(t_input_boosters[i]->param[t_input_boosters[i]->level]._PARAM_)) { \
max = (int)(t_input_boosters[i]->param[t_input_boosters[i]->level]._PARAM_); \
} \
} \
} \
if (max == INPUT_BOOSTER_NULL) { \
ref = INPUT_BOOSTER_NULL; \
} else { \
ref = max; \
} \
pr_booster("[Input Booster3] %s max value : %d\n", #_PARAM_, max); \
} \
int input_count = 0, key_back = 0, key_home = 0, key_recent = 0;
void input_booster_idle_state(void *__this, int input_booster_event);
void input_booster_press_state(void *__this, int input_booster_event);
void input_booster(struct input_dev *dev);
void input_booster_init(void);
#endif
#endif // Input Booster -