#include #include #include #include spinlock_t write_ib_lock; spinlock_t write_qos_lock; spinlock_t ib_type_lock; struct mutex trigger_ib_lock; struct workqueue_struct *ev_unbound_wq; struct workqueue_struct *ib_unbound_highwq; int total_ib_cnt = 0; int ib_init_succeed = 0; int level_value = IB_MAX; unsigned int debug_flag = 0; unsigned int enable_event_booster = INIT_ZERO; // Input Booster Init Variables int release_val[MAX_RES_COUNT]; int device_count = 0; struct t_ib_device_tree *ib_device_trees; struct t_ib_trigger *ib_trigger; int max_resource_size; struct list_head *ib_list; struct list_head *qos_list; // @evdev_mt_slot : save the number of inputed touch slot. int evdev_mt_slot = 0; // @evdev_mt_event[] : save count of each boooter's events. int evdev_mt_event[MAX_DEVICE_TYPE_NUM]; int trigger_cnt = 0; int send_ev_enable = 0; struct t_ib_info *find_release_ib(int dev_type, int key_id); struct t_ib_info *create_ib_instance(struct t_ib_trigger *p_IbTrigger, int uniqId); bool is_validate_uniqid(int dev_type, unsigned int uniq_id); struct t_ib_target *find_update_target(int uniq_id, int res_id); unsigned long get_qos_value(int res_id); void remove_ib_instance(struct t_ib_info *ib); void trigger_input_booster(struct work_struct *work) { unsigned int uniq_id = 0; int res_type = -1; struct t_ib_info *ib; struct t_ib_trigger *p_IbTrigger = container_of(work, struct t_ib_trigger, ib_trigger_work); if (p_IbTrigger == NULL) { return; } pr_booster("IB Trigger :: %s(%d) %s || key_id : %d\n =========================", ib_device_trees[p_IbTrigger->dev_type].label, p_IbTrigger->dev_type, (p_IbTrigger->event_type) ? "PRESS" : "RELEASE", p_IbTrigger->key_id); mutex_lock(&trigger_ib_lock); // Input booster On/Off handling if (p_IbTrigger->event_type == BOOSTER_ON) { if (find_release_ib(p_IbTrigger->dev_type, p_IbTrigger->key_id) != NULL) { pr_err(ITAG" IB Trigger :: ib already exist. Key(%d)", p_IbTrigger->key_id); mutex_unlock(&trigger_ib_lock); return; } // Check if uniqId exits. do { uniq_id = total_ib_cnt++; if (total_ib_cnt == MAX_IB_COUNT) total_ib_cnt = 0; } while (!is_validate_uniqid(p_IbTrigger->dev_type, uniq_id)); // Make ib instance with all needed factor. ib = create_ib_instance(p_IbTrigger, uniq_id); pr_booster("IB Uniq Id(%d)", uniq_id); if (ib == NULL) { mutex_unlock(&trigger_ib_lock); return; } ib->press_flag = FLAG_ON; // When create ib instance, insert resource info in qos list with value 0. for (res_type = 0; res_type < max_resource_size; res_type++) { if (ib != NULL && ib->ib_dt->res[res_type].head_value != 0) { struct t_ib_target* tv; tv = kmalloc(sizeof(struct t_ib_target), GFP_KERNEL); if (tv == NULL) continue; tv->uniq_id = ib->uniq_id; tv->value = 0; spin_lock(&write_qos_lock); list_add_tail_rcu(&(tv->list), &qos_list[res_type]); spin_unlock(&write_qos_lock); } } queue_work(ib_unbound_highwq, &(ib->ib_state_work[IB_HEAD])); } else { /* Find ib instance in the list. if not, ignore this event. * if exists, Release flag on. Call ib's Release func. */ ib = find_release_ib(p_IbTrigger->dev_type, p_IbTrigger->key_id); if (ib == NULL) { pr_err("IB is null on release"); mutex_unlock(&trigger_ib_lock); return; } pr_booster("IB Trigger Release :: Uniq ID(%d)", ib->uniq_id); mutex_lock(&ib->lock); ib->rel_flag = FLAG_ON; // If head operation is already finished, tail timeout work will be triggered. if (ib->isHeadFinished) { if (!delayed_work_pending(&(ib->ib_timeout_work[IB_TAIL]))) { queue_delayed_work(ib_unbound_highwq, &(ib->ib_timeout_work[IB_TAIL]), msecs_to_jiffies(ib->ib_dt->tail_time)); } else { pr_err(ITAG" IB Trigger Release :: tail timeout start"); } } mutex_unlock(&ib->lock); } mutex_unlock(&trigger_ib_lock); } struct t_ib_info *create_ib_instance(struct t_ib_trigger *p_IbTrigger, int uniqId) { struct t_ib_info *ib = kmalloc(sizeof(struct t_ib_info), GFP_KERNEL); int dev_type = p_IbTrigger->dev_type; if (ib == NULL) return NULL; ib->dev_name = p_IbTrigger->dev_name; ib->key_id = p_IbTrigger->key_id; ib->uniq_id = uniqId; ib->press_flag = FLAG_OFF; ib->rel_flag = FLAG_OFF; ib->isHeadFinished = 0; ib->ib_dt = &ib_device_trees[dev_type]; INIT_WORK(&ib->ib_state_work[IB_HEAD], press_state_func); INIT_DELAYED_WORK(&ib->ib_timeout_work[IB_HEAD], press_timeout_func); INIT_WORK(&ib->ib_state_work[IB_TAIL], release_state_func); INIT_DELAYED_WORK(&ib->ib_timeout_work[IB_TAIL], release_timeout_func); mutex_init(&ib->lock); spin_lock(&write_ib_lock); list_add_tail_rcu(&(ib->list), &ib_list[dev_type]); spin_unlock(&write_ib_lock); return ib; } bool is_validate_uniqid(int dev_type, unsigned int uniq_id) { int cnt = 0; struct t_ib_info *ib = NULL; rcu_read_lock(); if (list_empty(&ib_list[dev_type])) { rcu_read_unlock(); pr_booster("IB list empty"); return true; } list_for_each_entry_rcu(ib, &ib_list[dev_type], list) { cnt++; if (ib != NULL && ib->uniq_id == uniq_id) { rcu_read_unlock(); pr_booster("uniq id find :: IB Idx(%d) old(%d) new(%d)", cnt, ib->uniq_id, uniq_id); return false; } } rcu_read_unlock(); pr_booster("This can be used(IB Total:%d)", cnt); return true; } struct t_ib_info *find_release_ib(int dev_type, int key_id) { struct t_ib_info *ib = NULL; rcu_read_lock(); if (list_empty(&ib_list[dev_type])) { rcu_read_unlock(); pr_booster("Release IB(%d) Not Exist & List Empty", key_id); return NULL; } list_for_each_entry_rcu(ib, &ib_list[dev_type], list) { if (ib != NULL && ib->key_id == key_id && ib->rel_flag == FLAG_OFF) { rcu_read_unlock(); pr_booster("Release IB(%d) Found", key_id); return ib; } } rcu_read_unlock(); pr_booster("Release IB(%d) Not Exist", key_id); return NULL; } void press_state_func(struct work_struct *work) { struct t_ib_res_info res; struct t_ib_target *tv; int qos_values[MAX_RES_COUNT] = { 0, }; int res_type = 0; struct t_ib_info *target_ib = container_of(work, struct t_ib_info, ib_state_work[IB_HEAD]); pr_booster("Press State Func :::: Unique_Id(%d)", target_ib->uniq_id); // //To-Do : Get_Res_List(head) and update head value. for (res_type = 0; res_type < max_resource_size; res_type++) { res = target_ib->ib_dt->res[res_type]; if (res.head_value == 0) continue; //find already added target value instance and update value as a head. tv = find_update_target(target_ib->uniq_id, res.res_id); if (tv == NULL) { pr_booster("Press State Func :::: tv is null T.T"); continue; } tv->value = res.head_value; pr_booster("Press State Func :::: Uniq(%d)'s Update Res(%d) Head Val(%d)", tv->uniq_id, res.res_id, res.head_value); qos_values[res.res_id] = get_qos_value(res.res_id); } ib_set_booster(qos_values); pr_booster("Press State Func :::: Press Delay Time(%lu)", msecs_to_jiffies(target_ib->ib_dt->head_time)); queue_delayed_work(ib_unbound_highwq, &(target_ib->ib_timeout_work[IB_HEAD]), msecs_to_jiffies(target_ib->ib_dt->head_time)); } void press_timeout_func(struct work_struct *work) { struct t_ib_info *target_ib = container_of(work, struct t_ib_info, ib_timeout_work[IB_HEAD].work); pr_booster("Press Timeout Func :::: Unique_Id(%d)", target_ib->uniq_id); int res_type; struct t_ib_res_info res; struct t_ib_target *tv; int qos_values[MAX_RES_COUNT] = { 0, }; if (target_ib->ib_dt->tail_time != 0) { mutex_lock(&target_ib->lock); target_ib->isHeadFinished = 1; queue_work(ib_unbound_highwq, &(target_ib->ib_state_work[IB_TAIL])); mutex_unlock(&target_ib->lock); } else { //NO TAIL Scenario : Delete Ib instance and free all memory space. for (res_type = 0; res_type < max_resource_size; res_type++) { res = target_ib->ib_dt->res[res_type]; tv = find_update_target(target_ib->uniq_id, res.res_id); if (tv == NULL) continue; spin_lock(&write_qos_lock); list_del_rcu(&(tv->list)); spin_unlock(&write_qos_lock); synchronize_rcu(); kfree(tv); rcu_read_lock(); if (!list_empty(&qos_list[res.res_id])) { rcu_read_unlock(); qos_values[res.res_id] = get_qos_value(res.res_id); pr_booster("Press Timeout ::: Remove Val Cuz No Tail ::: Res(%d) Qos Val(%d)", res.res_id, qos_values[res.res_id]); } else { rcu_read_unlock(); pr_booster("Press Timeout ::: Release Booster(%d) ::: No Tail and List Empty", res.res_id); ib_release_booster(res.res_id); } } remove_ib_instance(target_ib); ib_set_booster(qos_values); } } void release_state_func(struct work_struct *work) { int qos_values[MAX_RES_COUNT] = { 0, }; int isHeadFinished = -1; int res_type = 0; struct t_ib_target *tv; struct t_ib_res_info res; struct t_ib_info *target_ib = container_of(work, struct t_ib_info, ib_state_work[IB_TAIL]); mutex_lock(&target_ib->lock); isHeadFinished = target_ib->isHeadFinished; pr_booster("Release State Func :::: Unique_Id(%d) HeadFinish(%d) Rel_Flag(%d)", target_ib->uniq_id, isHeadFinished, target_ib->rel_flag) for (res_type = 0; res_type < max_resource_size; res_type++) { res = target_ib->ib_dt->res[res_type]; if (res.tail_value == 0) continue; tv = find_update_target(target_ib->uniq_id, res.res_id); if (tv == NULL) continue; spin_lock(&write_qos_lock); tv->value = res.tail_value; spin_unlock(&write_qos_lock); pr_booster("Release State Func :::: Uniq(%d)'s Update Tail Val (%d), Qos_Val(%d)", tv->uniq_id, tv->value, qos_values[res.res_id]); qos_values[res.res_id] = get_qos_value(res.res_id); } ib_set_booster(qos_values); // If release event already triggered, tail delay work will be triggered after relese state func. if (target_ib->rel_flag == FLAG_ON) { if (!delayed_work_pending(&(target_ib->ib_timeout_work[IB_TAIL]))) { queue_delayed_work(ib_unbound_highwq, &(target_ib->ib_timeout_work[IB_TAIL]), msecs_to_jiffies(target_ib->ib_dt->tail_time)); } else { pr_err(ITAG" Release State Func :: tail timeout start"); } } mutex_unlock(&target_ib->lock); } void release_timeout_func(struct work_struct *work) { int qos_values[MAX_RES_COUNT] = { 0, }; struct t_ib_target *tv; struct t_ib_res_info res; int res_type; struct t_ib_info *target_ib = container_of(work, struct t_ib_info, ib_timeout_work[IB_TAIL].work); pr_booster("Release Timeout Func :::: Unique_Id(%d)", target_ib->uniq_id); // Remove all booster // delete instance in the ib list and delete instance in the qos list. for (res_type = 0; res_type < max_resource_size; res_type++) { res = target_ib->ib_dt->res[res_type]; tv = find_update_target(target_ib->uniq_id, res.res_id); if (tv == NULL) continue; pr_booster("Release Timeout Func :::: Delete Uniq(%d)'s TV Val (%d)", tv->uniq_id, tv->value); spin_lock(&write_qos_lock); list_del_rcu(&(tv->list)); spin_unlock(&write_qos_lock); synchronize_rcu(); kfree(tv); rcu_read_lock(); if (!list_empty(&qos_list[res.res_id])) { rcu_read_unlock(); qos_values[res.res_id] = get_qos_value(res.res_id); pr_booster("Release Timeout Func ::: Res(%d) Qos Val(%d)", res.res_id, qos_values[res.res_id]); } else { rcu_read_unlock(); pr_booster("Release Timeout ::: Release Booster(%d) ::: List Empty", res.res_id); ib_release_booster(res.res_id); } } ib_set_booster(qos_values); remove_ib_instance(target_ib); } struct t_ib_target *find_update_target(int uniq_id, int res_id) { struct t_ib_target *tv; rcu_read_lock(); list_for_each_entry_rcu(tv, &qos_list[res_id], list) { if (tv->uniq_id == uniq_id) { rcu_read_unlock(); return tv; } } rcu_read_unlock(); return NULL; } unsigned long get_qos_value(int res_id) { //Find tv instance that has max value in the qos_list that has the passed res_id. struct t_ib_target *tv; int ret_val = 0; rcu_read_lock(); if (list_empty(&qos_list[res_id])) { rcu_read_unlock(); return 0; } list_for_each_entry_rcu(tv, &qos_list[res_id], list) { if (tv->value > ret_val) ret_val = tv->value; } rcu_read_unlock(); return ret_val; } void remove_ib_instance(struct t_ib_info *ib) { pr_booster("Del Ib Instance's Id : %d", ib->uniq_id); //Delete Kmalloc instances spin_lock(&write_ib_lock); list_del_rcu(&(ib->list)); spin_unlock(&write_ib_lock); synchronize_rcu(); kfree(ib); } unsigned int create_uniq_id(int type, int code, int slot) { //id1 | (id2 << num_bits_id1) | (id3 << (num_bits_id2 + num_bits_id1)) pr_booster("Create Key Id -> type(%d), code(%d), slot(%d)", type, code, slot); return (type << (TYPE_BITS + CODE_BITS)) | (code << CODE_BITS) | slot; } void ib_auto_test(int type, int code, int val) { send_ev_enable = 1; } //+++++++++++++++++++++++++++++++++++++++++++++++ STRUCT & VARIABLE FOR SYSFS +++++++++++++++++++++++++++++++++++++++++++++++// SYSFS_CLASS(enable_event, (buf, "%u\n", enable_event), 1) SYSFS_CLASS(debug_level, (buf, "%u\n", debug_level), 1) SYSFS_CLASS(sendevent, (buf, "%d\n", sendevent), 3) HEAD_TAIL_SYSFS_DEVICE(head) HEAD_TAIL_SYSFS_DEVICE(tail) LEVEL_SYSFS_DEVICE(level) struct attribute *dvfs_attributes[] = { &dev_attr_head.attr, &dev_attr_tail.attr, &dev_attr_level.attr, NULL, }; struct attribute_group dvfs_attr_group = { .attrs = dvfs_attributes, }; void init_sysfs_device(struct class *sysfs_class, struct t_ib_device_tree *ib_dt) { struct device *sysfs_dev; int ret = 0; sysfs_dev = device_create(sysfs_class, NULL, 0, ib_dt, "%s", ib_dt->label); if (IS_ERR(sysfs_dev)) { ret = IS_ERR(sysfs_dev); pr_booster("[Input Booster] Failed to create %s sysfs device[%d]n", ib_dt->label, ret); return; } ret = sysfs_create_group(&sysfs_dev->kobj, &dvfs_attr_group); if (ret) { pr_booster("[Input Booster] Failed to create %s sysfs groupn", ib_dt->label); return; } } int is_ib_init_succeed(void) { return (ib_trigger != NULL && ib_device_trees != NULL && ib_list != NULL && qos_list != NULL) ? 1 : 0; } void input_booster_exit(void) { int i = 0; kfree(ib_trigger); kfree(ib_device_trees); kfree(ib_list); kfree(qos_list); input_booster_exit_vendor(); } // ********** Init Booster ********** // void input_booster_init(void) { // ********** Load Frequency data from DTSI ********** struct device_node *np; int i; int ib_dt_size = sizeof(struct t_ib_device_tree); int ib_res_size = sizeof(struct t_ib_res_info); int list_head_size = sizeof(struct list_head); int ddr_info_size = sizeof(struct t_ddr_info); int res_type = 0; int ndevice_in_dt = 0; char rel_val_str[100]; size_t rel_val_size = 0; char *rel_val_pointer = NULL; const char *token = NULL; spin_lock_init(&write_ib_lock); spin_lock_init(&write_qos_lock); spin_lock_init(&ib_type_lock); mutex_init(&trigger_ib_lock); ev_unbound_wq = alloc_ordered_workqueue("ev_unbound_wq", WQ_HIGHPRI); ib_unbound_highwq = alloc_workqueue("ib_unbound_high_wq", WQ_UNBOUND | WQ_HIGHPRI, MAX_IB_COUNT); if (ev_unbound_wq == NULL || ib_unbound_highwq == NULL) goto out; //Input Booster Trigger Strcut Init ib_trigger = kcalloc(ABS_CNT, sizeof(struct t_ib_trigger) * MAX_IB_COUNT, GFP_KERNEL); if (ib_trigger == NULL) { pr_err(ITAG" ib_trigger mem alloc fail"); goto out; } for (i = 0; i < MAX_IB_COUNT; i++) { INIT_WORK(&(ib_trigger[i].ib_trigger_work), trigger_input_booster); } np = of_find_compatible_node(NULL, NULL, "input_booster"); if (np == NULL) { goto out; } // Geting the count of devices. ndevice_in_dt = of_get_child_count(np); pr_info(ITAG" %s ndevice_in_dt : %d\n", __func__, ndevice_in_dt); ib_device_trees = kcalloc(ABS_CNT, ib_dt_size * ndevice_in_dt, GFP_KERNEL); if (ib_device_trees == NULL) { pr_err(ITAG" dt_infor mem alloc fail"); goto out; } // ib list mem alloc ib_list = kcalloc(ABS_CNT, list_head_size * ndevice_in_dt, GFP_KERNEL); if (ib_list == NULL) { pr_err(ITAG" ib list mem alloc fail"); goto out; } sscanf((of_get_property(np, "max_resource_count", NULL)), "%d", &max_resource_size); pr_info(ITAG" resource size : %d", max_resource_size); //qos list mem alloc qos_list = kcalloc(ABS_CNT, list_head_size * max_resource_size, GFP_KERNEL); if (qos_list == NULL) { pr_err(ITAG" ib list mem alloc fail"); goto out; } //Init Resource Release Values const char *rel_vals = of_get_property(np, "ib_release_values", NULL); rel_val_size = strlcpy(rel_val_str, rel_vals, sizeof(char) * 100); rel_val_pointer = rel_val_str; token = strsep(&rel_val_pointer, ","); res_type = 0; while (token != NULL) { pr_booster("Rel %d's Type Value(%s)", res_type, token); //Release Values inserted inside array sscanf(token, "%d", &release_val[res_type]); //Init Qos List INIT_LIST_HEAD(&qos_list[res_type]); token = strsep(&rel_val_pointer, ","); res_type++; } if (res_type < max_resource_size) { pr_err(ITAG" release value parse fail"); goto out; } struct device_node *cnp; for_each_child_of_node(np, cnp) { /************************************************/ // fill all needed data into res_info instance that is in dt instance. struct t_ib_device_tree *ib_dt = (ib_device_trees + device_count); struct device_node *child_resource_node; struct device_node *resource_node = of_find_compatible_node(cnp, NULL, "resource"); ib_dt->res = kcalloc(ABS_CNT, ib_res_size * max_resource_size, GFP_KERNEL); int resource_node_index = 0; int res_type = 0; for_each_child_of_node(resource_node, child_resource_node) { // resource_node_index is same as Resource's ID. ib_dt->res[resource_node_index].res_id = resource_node_index; ib_dt->res[resource_node_index].label = of_get_property(child_resource_node, "resource,label", NULL); int inputbooster_size = 0; const u32 *is_exist_inputbooster_size = of_get_property(child_resource_node, "resource,value", &inputbooster_size); if (is_exist_inputbooster_size && inputbooster_size) { inputbooster_size = inputbooster_size / sizeof(u32); } pr_info(ITAG" inputbooster_size : %d", inputbooster_size); if (inputbooster_size != 2) return; // error for (res_type = 0; res_type < inputbooster_size; ++res_type) { if (res_type == IB_HEAD) { of_property_read_u32_index(child_resource_node, "resource,value", res_type, &ib_dt->res[resource_node_index].head_value); pr_info(ITAG"res[%d]->values[%d] : %d", resource_node_index, res_type, ib_dt->res[resource_node_index].head_value); } else if (res_type == IB_TAIL) { of_property_read_u32_index(child_resource_node, "resource,value", res_type, &ib_dt->res[resource_node_index].tail_value); pr_info(ITAG"res[%d]->values[%d] : %d", resource_node_index, res_type, ib_dt->res[resource_node_index].tail_value); } } resource_node_index++; } ib_dt->label = of_get_property(cnp, "input_booster,label", NULL); pr_info(ITAG" %s ib_dt->label : %s\n", __func__, ib_dt->label); if (of_property_read_u32(cnp, "input_booster,type", &ib_dt->type)) { pr_err(ITAG" Failed to get type property\n"); break; } if (of_property_read_u32(cnp, "input_booster,head_time", &ib_dt->head_time)) { pr_err(ITAG" Fail Get Head Time\n"); break; } if (of_property_read_u32(cnp, "input_booster,tail_time", &ib_dt->tail_time)) { pr_err(ITAG" Fail Get Tail Time\n"); break; } //Init all type of ib list. INIT_LIST_HEAD(&ib_list[device_count]); device_count++; } ib_init_succeed = is_ib_init_succeed(); out: // ********** Initialize Sysfs ********** { struct class *sysfs_class; int ret; int ib_type; sysfs_class = class_create(THIS_MODULE, "input_booster"); if (IS_ERR(sysfs_class)) { pr_err(" Failed to create class\n"); return; } if (ib_init_succeed) { INIT_SYSFS_CLASS(enable_event) INIT_SYSFS_CLASS(debug_level) INIT_SYSFS_CLASS(sendevent) for (ib_type = 0; ib_type < MAX_DEVICE_TYPE_NUM; ib_type++) { init_sysfs_device(sysfs_class, &ib_device_trees[ib_type]); } } } #if !defined(CONFIG_ARCH_QCOM) && !defined (CONFIG_ARCH_EXYNOS) pr_err(ITAG" At least, one vendor feature needed\n"); #else input_booster_init_vendor(release_val); #endif }