android/android_kernel_xiaomi_sm8450
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

input: synaptics_s3907: Make it compile

Browse Source 
This requires switching to the panel notifier API from the mi disp
notifier.

Change-Id: I4158f9d61241eec57d1a44da4811c62077cf9814
Signed-off-by: Jens Reidel <adrian@travitia.xyz>
This commit is contained in:
Jens Reidel 2024-04-17 16:55:57 +02:00
parent 629fb1f2b4
commit e3739e4b0e
No known key found for this signature in database
GPG Key ID: 23C1E5F512C12303
3 changed files with 101 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

171
drivers/input/touchscreen/synaptics_s3907/synaptics_tcm_core.c
View File

@ -3666,7 +3666,7 @@ static void syna_tcm_helper_work(struct work_struct *work)
#if defined(CONFIG_PM) || defined(CONFIG_FB) #if defined(CONFIG_PM) || defined(CONFIG_FB)
static int syna_tcm_pm_resume(struct device *dev) static int syna_tcm_pm_resume(struct device *dev)
{ {
int retval; int i, retval;
struct syna_tcm_module_handler *mod_handler; struct syna_tcm_module_handler *mod_handler;
struct syna_tcm_hcd *tcm_hcd = dev_get_drvdata(dev); struct syna_tcm_hcd *tcm_hcd = dev_get_drvdata(dev);
@ -3711,7 +3711,7 @@ static int syna_tcm_pm_resume(struct device *dev)
retval = tcm_hcd->sleep(tcm_hcd, false); retval = tcm_hcd->sleep(tcm_hcd, false);
if (retval < 0) { if (retval < 0) {
for (int i = 0; i < 5; i++) { for (i = 0; i < 5; i++) {
msleep(5); msleep(5);
retval = tcm_hcd->sleep(tcm_hcd, false); retval = tcm_hcd->sleep(tcm_hcd, false);
if (retval < 0) { if (retval < 0) {
@ -3978,27 +3978,27 @@ static void syna_tcm_suspend_work(struct work_struct *work)
return; return;
} }
static int syna_tcm_drm_state_notifier_callback(struct notifier_block *nb, #if defined(CONFIG_DRM)
unsigned long action, static void syna_tcm_drm_state_notifier_callback(
void *data) enum panel_event_notifier_tag notifier_tag,
struct panel_event_notification *notification, void *client_data)
{ {
int retval = 0; int retval = 0;
int transition; struct syna_tcm_hcd *tcm_hcd = client_data;
struct mi_disp_notifier *evdata = data;
struct syna_tcm_hcd *tcm_hcd =
container_of(nb, struct syna_tcm_hcd, notifier);
if (!(action == MI_DISP_DPMS_EARLY_EVENT || if (!notification) {
action == MI_DISP_DPMS_EVENT || action == MI_DISP_CHANGE_FPS)) { LOGE(tcm_hcd->pdev->dev.parent, "Invalid notification\n");
LOGE(tcm_hcd->pdev->dev.parent, return;
"event(%lu) do not need process\n", action);
return 0;
} }
if (evdata && evdata->data && tcm_hcd) { switch (notification->notif_type) {
transition = *(int *)(evdata->data); case DRM_PANEL_EVENT_UNBLANK:
if (atomic_read(&tcm_hcd->firmware_flashing) && LOGN(tcm_hcd->pdev->dev.parent, "touch resume\n");
transition == MI_DISP_DPMS_POWERDOWN) { queue_work(tcm_hcd->event_wq, &tcm_hcd->resume_work);
break;
case DRM_PANEL_EVENT_BLANK:
case DRM_PANEL_EVENT_BLANK_LP:
if (atomic_read(&tcm_hcd->firmware_flashing)) {
retval = wait_event_interruptible_timeout( retval = wait_event_interruptible_timeout(
tcm_hcd->reflash_wq, tcm_hcd->reflash_wq,
!atomic_read(&tcm_hcd->firmware_flashing), !atomic_read(&tcm_hcd->firmware_flashing),
@ -4007,47 +4007,27 @@ static int syna_tcm_drm_state_notifier_callback(struct notifier_block *nb,
LOGE(tcm_hcd->pdev->dev.parent, LOGE(tcm_hcd->pdev->dev.parent,
"Timed out waiting for completion of flashing firmware\n"); "Timed out waiting for completion of flashing firmware\n");
atomic_set(&tcm_hcd->firmware_flashing, 0); atomic_set(&tcm_hcd->firmware_flashing, 0);
return -EIO; return;
} else {
retval = 0;
} }
} }
flush_workqueue(tcm_hcd->event_wq); if (notification->notif_data.early_trigger) {
if (action == MI_DISP_DPMS_EARLY_EVENT &&
(transition == MI_DISP_DPMS_POWERDOWN)) {
LOGN(tcm_hcd->pdev->dev.parent, LOGN(tcm_hcd->pdev->dev.parent,
"touch early_suspend by powerdown 0x%04x\n", "touch early suspend\n");
transition);
queue_work(tcm_hcd->event_wq, queue_work(tcm_hcd->event_wq,
&tcm_hcd->early_suspend_work); &tcm_hcd->early_suspend_work);
} else if (action == MI_DISP_DPMS_EVENT) { } else {
if (transition == MI_DISP_DPMS_POWERDOWN) { LOGN(tcm_hcd->pdev->dev.parent, "touch suspend\n");
LOGN(tcm_hcd->pdev->dev.parent, queue_work(tcm_hcd->event_wq, &tcm_hcd->suspend_work);
"touch suspend by powerdown 0x%04x\n",
transition);
queue_work(tcm_hcd->event_wq,
&tcm_hcd->suspend_work);
} else if (transition == MI_DISP_DPMS_LP1 ||
transition == MI_DISP_DPMS_LP2) {
LOGN(tcm_hcd->pdev->dev.parent,
"touch suspend by doze 0x%04x\n",
transition);
queue_work(tcm_hcd->event_wq,
&tcm_hcd->suspend_work);
} else if (transition == MI_DISP_DPMS_ON) {
LOGN(tcm_hcd->pdev->dev.parent,
"touch resume\n");
queue_work(tcm_hcd->event_wq,
&tcm_hcd->resume_work);
} }
} else if (action == MI_DISP_CHANGE_FPS) break;
LOGI(tcm_hcd->pdev->dev.parent, default:
"tp received fps change, new:%d\n", transition); LOGE(tcm_hcd->pdev->dev.parent, "notification serviced: %d\n",
notification->notif_type);
break;
} }
return 1;
} }
#endif
#ifdef SYNA_TCM_XIAOMI_TOUCHFEATURE #ifdef SYNA_TCM_XIAOMI_TOUCHFEATURE
static struct xiaomi_touch_interface *p_xiaomi_touch_interfaces = NULL; static struct xiaomi_touch_interface *p_xiaomi_touch_interfaces = NULL;
@ -5728,7 +5708,7 @@ static const struct file_operations tpdbg_operations = {
#endif #endif
#ifdef SYNAPTICS_POWERSUPPLY_CB #ifdef SYNAPTICS_POWERSUPPLY_CB
static int syna_tcm_get_charging_status() static int syna_tcm_get_charging_status(void)
{ {
struct power_supply *usb_psy; struct power_supply *usb_psy;
union power_supply_propval val; union power_supply_propval val;
@ -6193,14 +6173,13 @@ static char syna_tcm_touch_vendor_read(void)
} }
#endif #endif
#if defined(CONFIG_DRM)
/* /*
* pointer active_panel initlized function, used to checkout panel(config)from devices * pointer active_panel initlized function, used to checkout panel(config)from devices
* tree , later will be passed to drm_notifyXXX function. * tree , later will be passed to drm_notifyXXX function.
* @param device node contains the panel * @param device node contains the panel
* @return pointer to that panel if panel truely exists, otherwise negative number * @return pointer to that panel if panel truely exists, otherwise negative number
*/ */
/*
extern struct drm_panel *mi_of_drm_find_panel_for_touch(const struct device_node *np);
static int ts_check_panel(struct device_node *np) static int ts_check_panel(struct device_node *np)
{ {
int i; int i;
@ -6209,29 +6188,65 @@ static int ts_check_panel(struct device_node *np)
struct drm_panel *panel; struct drm_panel *panel;
count = of_count_phandle_with_args(np, "panel", NULL); count = of_count_phandle_with_args(np, "panel", NULL);
printk("count = %d", count);
if (count <= 0) if (count <= 0)
return -ENODEV; return -ENODEV;
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
node = of_parse_phandle(np, "panel", i); node = of_parse_phandle(np, "panel", i);
panel = mi_of_drm_find_panel_for_touch(node); panel = of_drm_find_panel(node);
of_node_put(node); of_node_put(node);
if (!IS_ERR(panel)) { if (!IS_ERR(panel)) {
active_panel = panel; active_panel = panel;
if (active_panel) {
printk("active_panel, ok");
}
return 0; return 0;
} else { } else {
active_panel = NULL; active_panel = NULL;
} }
} }
return PTR_ERR(panel); return PTR_ERR(panel);
} }
*/
static void ts_register_panel_notifier_work(struct work_struct *work)
{
struct syna_tcm_hcd *tcm_hcd = container_of(
work, struct syna_tcm_hcd, panel_notifier_register_work.work);
int error;
static int check_count = 0;
struct spi_device *spi;
struct device_node *dp;
spi = to_spi_device(tcm_hcd->pdev->dev.parent);
dp = spi->dev.of_node;
LOGE(tcm_hcd->pdev->dev.parent, "Start register panel notifier\n");
error = ts_check_panel(dp);
if (!dp || !active_panel) {
LOGE(tcm_hcd->pdev->dev.parent,
"Failed to register panel notifier, try again\n");
if (check_count++ < 5) {
schedule_delayed_work(
&tcm_hcd->panel_notifier_register_work,
msecs_to_jiffies(5000));
} else {
LOGE(tcm_hcd->pdev->dev.parent,
"Failed to register panel notifier, not trying again\n");
}
return;
}
if (active_panel) {
tcm_hcd->notifier_cookie = panel_event_notifier_register(
PANEL_EVENT_NOTIFICATION_PRIMARY,
PANEL_EVENT_NOTIFIER_CLIENT_PRIMARY_TOUCH, active_panel,
&syna_tcm_drm_state_notifier_callback, (void *)tcm_hcd);
if (!tcm_hcd->notifier_cookie) {
LOGE(tcm_hcd->pdev->dev.parent,
"Failed to register for panel events\n");
}
}
}
#endif
static int syna_tcm_probe(struct platform_device *pdev) static int syna_tcm_probe(struct platform_device *pdev)
{ {
@ -6496,12 +6511,12 @@ static int syna_tcm_probe(struct platform_device *pdev)
INIT_WORK(&tcm_hcd->set_report_rate_work, INIT_WORK(&tcm_hcd->set_report_rate_work,
syna_tcm_set_report_rate_work); syna_tcm_set_report_rate_work);
tcm_hcd->notifier.notifier_call = syna_tcm_drm_state_notifier_callback; #if defined(CONFIG_DRM)
retval = mi_disp_register_client(&tcm_hcd->notifier); INIT_DELAYED_WORK(&tcm_hcd->panel_notifier_register_work,
if (retval < 0) { ts_register_panel_notifier_work);
LOGE(tcm_hcd->pdev->dev.parent, schedule_delayed_work(&tcm_hcd->panel_notifier_register_work,
"ERROR: register notifier failed, retval=%d\n", retval); msecs_to_jiffies(5000));
} #endif
#ifdef SYNA_TCM_XIAOMI_TOUCHFEATURE #ifdef SYNA_TCM_XIAOMI_TOUCHFEATURE
tcm_hcd->game_wq = tcm_hcd->game_wq =
@ -6706,7 +6721,11 @@ static int syna_tcm_probe(struct platform_device *pdev)
syna_tcm_debugfs_exit(); syna_tcm_debugfs_exit();
#endif #endif
mi_disp_unregister_client(&tcm_hcd->notifier); #if defined(CONFIG_DRM)
cancel_delayed_work_sync(&tcm_hcd->panel_notifier_register_work);
if (active_panel && tcm_hcd->notifier_cookie)
panel_event_notifier_unregister(tcm_hcd->notifier_cookie);
#endif
err_pm_event_wq: err_pm_event_wq:
/* cancel_work_sync(&tcm_hcd->early_suspend_work); /* cancel_work_sync(&tcm_hcd->early_suspend_work);
@ -6720,10 +6739,6 @@ static int syna_tcm_probe(struct platform_device *pdev)
err_create_run_kthread: err_create_run_kthread:
#endif #endif
#ifdef CONFIG_FB
fb_unregister_client(&tcm_hcd->fb_notifier);
#endif
if (tcm_hcd->tp_lockdown_info_proc) if (tcm_hcd->tp_lockdown_info_proc)
remove_proc_entry("tp_lockdown_info", NULL); remove_proc_entry("tp_lockdown_info", NULL);
if (tcm_hcd->tp_fw_version_proc) if (tcm_hcd->tp_fw_version_proc)
@ -6859,7 +6874,13 @@ static int syna_tcm_remove(struct platform_device *pdev)
flush_workqueue(tcm_hcd->watchdog.workqueue); flush_workqueue(tcm_hcd->watchdog.workqueue);
destroy_workqueue(tcm_hcd->watchdog.workqueue); destroy_workqueue(tcm_hcd->watchdog.workqueue);
#endif #endif
mi_disp_unregister_client(&tcm_hcd->notifier);
#if defined(CONFIG_DRM)
cancel_delayed_work_sync(&tcm_hcd->panel_notifier_register_work);
if (active_panel && tcm_hcd->notifier_cookie)
panel_event_notifier_unregister(tcm_hcd->notifier_cookie);
#endif
cancel_work_sync(&tcm_hcd->helper.work); cancel_work_sync(&tcm_hcd->helper.work);
flush_workqueue(tcm_hcd->helper.workqueue); flush_workqueue(tcm_hcd->helper.workqueue);
destroy_workqueue(tcm_hcd->helper.workqueue); destroy_workqueue(tcm_hcd->helper.workqueue);
@ -6879,10 +6900,6 @@ static int syna_tcm_remove(struct platform_device *pdev)
kthread_stop(tcm_hcd->notifier_thread); kthread_stop(tcm_hcd->notifier_thread);
#endif #endif
#ifdef CONFIG_FB
fb_unregister_client(&tcm_hcd->fb_notifier);
#endif
for (idx = 0; idx < ARRAY_SIZE(dynamic_config_attrs); idx++) { for (idx = 0; idx < ARRAY_SIZE(dynamic_config_attrs); idx++) {
sysfs_remove_file(tcm_hcd->dynamnic_config_sysfs_dir, sysfs_remove_file(tcm_hcd->dynamnic_config_sysfs_dir,
&(*dynamic_config_attrs[idx]).attr); &(*dynamic_config_attrs[idx]).attr);

12
drivers/input/touchscreen/synaptics_s3907/synaptics_tcm_core.h
View File

@ -49,12 +49,14 @@
#include <linux/spi/spi.h> #include <linux/spi/spi.h>
#include <linux/of_gpio.h> #include <linux/of_gpio.h>
#include <linux/fb.h> #if defined(CONFIG_DRM)
#include <linux/soc/qcom/panel_event_notifier.h>
#include <drm/drm_panel.h>
#endif
#include <linux/notifier.h> #include <linux/notifier.h>
#include "synaptics_tcm.h" #include "synaptics_tcm.h"
#include "../xiaomi/xiaomi_touch.h" #include "../xiaomi/xiaomi_touch.h"
#include "synaptics_tcm_xiaomi_board_data.h" #include "synaptics_tcm_xiaomi_board_data.h"
#include "../../../gpu/drm/mediatek/mediatek_v2/mi_disp/mi_disp_notifier.h"
#ifdef SYNAPTICS_DEBUGFS_ENABLE #ifdef SYNAPTICS_DEBUGFS_ENABLE
#include <linux/debugfs.h> #include <linux/debugfs.h>
@ -625,10 +627,10 @@ struct syna_tcm_hcd {
struct device *syna_tcm_dev; struct device *syna_tcm_dev;
dev_t tp_dev_num; dev_t tp_dev_num;
struct notifier_block notifier; struct notifier_block notifier;
struct notifier_block fb_notifier;
struct notifier_block power_supply_notifier; struct notifier_block power_supply_notifier;
int charging_status; int charging_status;
struct delayed_work power_supply_work; struct delayed_work power_supply_work;
struct delayed_work panel_notifier_register_work;
struct syna_tcm_buffer in; struct syna_tcm_buffer in;
struct syna_tcm_buffer out; struct syna_tcm_buffer out;
struct syna_tcm_buffer resp; struct syna_tcm_buffer resp;
@ -933,8 +935,6 @@ static inline unsigned int ceil_div(unsigned int dividend, unsigned divisor)
return (dividend + divisor - 1) / divisor; return (dividend + divisor - 1) / divisor;
} }
int mi_disp_register_client(struct notifier_block *nb);
void touch_fod_test(int value); void touch_fod_test(int value);
int touch_free_objects(struct syna_tcm_hcd *tcm_hcd); int touch_free_objects(struct syna_tcm_hcd *tcm_hcd);
@ -943,6 +943,4 @@ int touch_flush_slots(struct syna_tcm_hcd *tcm_hcd);
int touch_update_fod_enable_value(struct syna_tcm_hcd *tcm_hcd); int touch_update_fod_enable_value(struct syna_tcm_hcd *tcm_hcd);
extern int mi_disp_set_fod_queue_work(u32 fod_btn, bool from_touch);
#endif #endif

4
drivers/input/touchscreen/synaptics_s3907/synaptics_tcm_touch.c
View File

@ -185,7 +185,6 @@ void touch_fod_test(int value)
input_report_key(touch_hcd->input_dev, BTN_INFO, 1); input_report_key(touch_hcd->input_dev, BTN_INFO, 1);
input_sync(touch_hcd->input_dev); input_sync(touch_hcd->input_dev);
update_fod_press_status(1); update_fod_press_status(1);
mi_disp_set_fod_queue_work(1, true);
input_mt_slot(touch_hcd->input_dev, 0); input_mt_slot(touch_hcd->input_dev, 0);
input_mt_report_slot_state(touch_hcd->input_dev, MT_TOOL_FINGER, input_mt_report_slot_state(touch_hcd->input_dev, MT_TOOL_FINGER,
1); 1);
@ -208,7 +207,6 @@ void touch_fod_test(int value)
input_report_abs(touch_hcd->input_dev, ABS_MT_TRACKING_ID, -1); input_report_abs(touch_hcd->input_dev, ABS_MT_TRACKING_ID, -1);
input_report_key(touch_hcd->input_dev, BTN_INFO, 0); input_report_key(touch_hcd->input_dev, BTN_INFO, 0);
update_fod_press_status(0); update_fod_press_status(0);
mi_disp_set_fod_queue_work(0, true);
input_sync(touch_hcd->input_dev); input_sync(touch_hcd->input_dev);
} }
} }
@ -224,7 +222,6 @@ static void touch_fod_down_event(void)
LOGI(tcm_hcd->pdev->dev.parent, "FOD DOWN Dfetected\n"); LOGI(tcm_hcd->pdev->dev.parent, "FOD DOWN Dfetected\n");
tcm_hcd->fod_display_enabled = true; tcm_hcd->fod_display_enabled = true;
update_fod_press_status(1); update_fod_press_status(1);
mi_disp_set_fod_queue_work(1, true);
} }
} }
@ -243,7 +240,6 @@ static void touch_fod_up_event(void)
tcm_hcd->fod_display_enabled = false; tcm_hcd->fod_display_enabled = false;
fod_id = TOUCH_FOD_INVALID_ID; fod_id = TOUCH_FOD_INVALID_ID;
update_fod_press_status(0); update_fod_press_status(0);
mi_disp_set_fod_queue_work(0, true);
} }
int touch_flush_slots(struct syna_tcm_hcd *tcm_hcd) int touch_flush_slots(struct syna_tcm_hcd *tcm_hcd)