Add devicetree bindings for the Focaltech FTS touchscreen drivers.

Signed-off-by: Caleb Connolly caleb@connolly.tech --- .../input/touchscreen/focaltech,fts.yaml | 78 +++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 Documentation/devicetree/bindings/input/touchscreen/focaltech,fts.yaml

diff --git a/Documentation/devicetree/bindings/input/touchscreen/focaltech,fts.yaml b/Documentation/devicetree/bindings/input/touchscreen/focaltech,fts.yaml new file mode 100644 index 000000000000..bb25a4f8ad71 --- /dev/null +++ b/Documentation/devicetree/bindings/input/touchscreen/focaltech,fts.yaml @@ -0,0 +1,78 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/input/touchscreen/focaltech,fts.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Focaltech FTS I2C Touchscreen Controller + +maintainers: + - Caleb Connolly caleb@connolly.tech + +allOf: + - $ref: touchscreen.yaml# + +properties: + compatible: + enum: + - focaltech,fts5452 + - focaltech,fts8719 + reg: + const: 0x38 + + interrupts: + maxItems: 1 + + reset-gpios: + maxItems: 1 + + wakeup-source: + type: boolean + description: touchscreen can be used as a wakeup source. + + focaltech,max-touch-number: + $ref: /schemas/types.yaml#/definitions/uint32 + description: max number of fingers supported + minimum: 2 + maximum: 10 + + touchscreen-size-x: true + touchscreen-size-y: true + +additionalProperties: false + +required: + - compatible + - reg + - reset-gpios + - focaltech,max-touch-number + - touchscreen-size-x + - touchscreen-size-y + +examples: + - | + #include <dt-bindings/interrupt-controller/irq.h> + #include <dt-bindings/gpio/gpio.h> + &i2c5 { + status="okay"; + + touchscreen: focaltech@38 { + compatible = "focaltech,fts8719"; + reg = <0x38>; + wakeup-source; + interrupt-parent = <&tlmm>; + interrupts = <125 0x2>; + vdd-supply = <&vreg_l28a_3p0>; + vcc-i2c-supply = <&vreg_l14a_1p88>; + + pinctrl-names = "default", "suspend"; + pinctrl-0 = <&ts_int_active &ts_reset_active>; + pinctrl-1 = <&ts_int_suspend &ts_reset_suspend>; + + reset-gpio = <&tlmm 99 GPIO_ACTIVE_HIGH>; + irq-gpio = <&tlmm 125 GPIO_TRANSITORY>; + touchscreen-size-x = <1080>; + touchscreen-size-y = <2160>; + focaltech,max-touch-number = <5>; + }; + }; -- 2.34.1

The focaltech FTS driver supports several variants of focaltech touch screens found in ~2018 era smartphones including a variant of the PocoPhone F1 and the SHIFT6mq. This driver is loosely based on the original driver from Focaltech but has been simplified and largely reworked.

Signed-off-by: Caleb Connolly caleb@connolly.tech --- drivers/input/touchscreen/Kconfig | 9 + drivers/input/touchscreen/Makefile | 1 + drivers/input/touchscreen/focaltech_fts.c | 870 ++++++++++++++++++++++ 3 files changed, 880 insertions(+) create mode 100644 drivers/input/touchscreen/focaltech_fts.c

diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig index 2f6adfb7b938..10874f2d17ac 100644 --- a/drivers/input/touchscreen/Kconfig +++ b/drivers/input/touchscreen/Kconfig @@ -372,6 +372,15 @@ config TOUCHSCREEN_EXC3000 To compile this driver as a module, choose M here: the module will be called exc3000.

+config TOUCHSCREEN_FOCALTECH_FTS + tristate "Focaltech FTS Touchscreen" + depends on I2C + help + Say Y here to enable support for Focaltech FTS based + touch panels, including the 5452 and 8917 panels. + + If unsure, say N. + config TOUCHSCREEN_FUJITSU tristate "Fujitsu serial touchscreen" select SERIO diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile index 39a8127cf6a5..79f877d4ba02 100644 --- a/drivers/input/touchscreen/Makefile +++ b/drivers/input/touchscreen/Makefile @@ -44,6 +44,7 @@ obj-$(CONFIG_TOUCHSCREEN_ELO) += elo.o obj-$(CONFIG_TOUCHSCREEN_EGALAX) += egalax_ts.o obj-$(CONFIG_TOUCHSCREEN_EGALAX_SERIAL) += egalax_ts_serial.o obj-$(CONFIG_TOUCHSCREEN_EXC3000) += exc3000.o +obj-$(CONFIG_TOUCHSCREEN_FOCALTECH_FTS) += focaltech_fts.o obj-$(CONFIG_TOUCHSCREEN_FUJITSU) += fujitsu_ts.o obj-$(CONFIG_TOUCHSCREEN_GOODIX) += goodix_ts.o obj-$(CONFIG_TOUCHSCREEN_HIDEEP) += hideep.o diff --git a/drivers/input/touchscreen/focaltech_fts.c b/drivers/input/touchscreen/focaltech_fts.c new file mode 100644 index 000000000000..c62dc40a5bd0 --- /dev/null +++ b/drivers/input/touchscreen/focaltech_fts.c @@ -0,0 +1,870 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * + * FocalTech touchscreen driver. + * + * Copyright (c) 2010-2017, FocalTech Systems, Ltd., all rights reserved. + * Copyright (C) 2018 XiaoMi, Inc. + * Copyright (c) 2021 Caleb Connolly caleb@connolly.tech + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include <linux/i2c.h> +#include <linux/input.h> +#include <linux/input/mt.h> +#include <linux/slab.h> +#include <linux/interrupt.h> +#include <linux/delay.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/gpio.h> +#include <linux/of_gpio.h> +#include <linux/of_device.h> +#include <linux/regulator/consumer.h> +#include <linux/mutex.h> +#include <linux/wait.h> +#include <linux/time.h> +#include <linux/workqueue.h> +#include <linux/uaccess.h> +#include <linux/version.h> +#include <linux/types.h> +#include <linux/device.h> +#include <linux/netdevice.h> +#include <linux/unistd.h> +#include <linux/vmalloc.h> +#include <linux/notifier.h> + +#define FTS_CMD_START1 0x55 +#define FTS_CMD_START2 0xAA +#define FTS_CMD_START_DELAY 10 +#define FTS_CMD_READ_ID 0x90 +#define FTS_CMD_READ_ID_LEN 4 + +#define FTS_REG_INT_CNT 0x8F +#define FTS_REG_FLOW_WORK_CNT 0x91 +#define FTS_REG_WORKMODE 0x00 +#define FTS_REG_WORKMODE_FACTORY_VALUE 0x40 +#define FTS_REG_WORKMODE_WORK_VALUE 0x00 +#define FTS_REG_ESDCHECK_DISABLE 0x8D +#define FTS_REG_CHIP_ID 0xA3 +#define FTS_REG_CHIP_ID2 0x9F +#define FTS_REG_POWER_MODE 0xA5 +#define FTS_REG_POWER_MODE_SLEEP_VALUE 0x03 +#define FTS_REG_FW_VER 0xA6 +#define FTS_REG_VENDOR_ID 0xA8 +#define FTS_REG_LCD_BUSY_NUM 0xAB +#define FTS_REG_FACE_DEC_MODE_EN 0xB0 +#define FTS_REG_FACE_DEC_MODE_STATUS 0x01 +#define FTS_REG_IDE_PARA_VER_ID 0xB5 +#define FTS_REG_IDE_PARA_STATUS 0xB6 +#define FTS_REG_GLOVE_MODE_EN 0xC0 +#define FTS_REG_COVER_MODE_EN 0xC1 +#define FTS_REG_CHARGER_MODE_EN 0x8B +#define FTS_REG_GESTURE_EN 0xD0 +#define FTS_REG_GESTURE_OUTPUT_ADDRESS 0xD3 +#define FTS_REG_MODULE_ID 0xE3 +#define FTS_REG_LIC_VER 0xE4 +#define FTS_REG_ESD_SATURATE 0xED + +#define FTS_MAX_POINTS_SUPPORT 10 +#define FTS_ONE_TCH_LEN 6 + +#define FTS_MAX_ID 0x0A +#define FTS_TOUCH_X_H_POS 3 +#define FTS_TOUCH_X_L_POS 4 +#define FTS_TOUCH_Y_H_POS 5 +#define FTS_TOUCH_Y_L_POS 6 +#define FTS_TOUCH_PRE_POS 7 +#define FTS_TOUCH_AREA_POS 8 +#define FTS_TOUCH_POINT_NUM 2 +#define FTS_TOUCH_EVENT_POS 3 +#define FTS_TOUCH_ID_POS 5 +#define FTS_COORDS_ARR_SIZE 2 + +#define FTS_TOUCH_DOWN 0 +#define FTS_TOUCH_UP 1 +#define FTS_TOUCH_CONTACT 2 + +#define EVENT_DOWN(flag) ((flag == FTS_TOUCH_DOWN) || (flag == FTS_TOUCH_CONTACT)) + +#define FTS_LOCKDOWN_INFO_SIZE 8 +#define LOCKDOWN_INFO_ADDR 0x1FA0 + +#define FTS_DRIVER_NAME "fts-i2c" +#define INTERVAL_READ_REG 100 /* unit:ms */ +#define TIMEOUT_READ_REG 2000 /* unit:ms */ +#define FTS_VDD_MIN_UV 2600000 +#define FTS_VDD_MAX_UV 3300000 +#define FTS_I2C_VCC_MIN_UV 1800000 +#define FTS_I2C_VCC_MAX_UV 1800000 + +#define I2C_RETRY_NUMBER 3 + +#define CHIP_TYPE_5452 0x5452 +#define CHIP_TYPE_8719 0x8719 + +static DEFINE_MUTEX(i2c_rw_access); + +struct ts_event { + int x; /*x coordinate */ + int y; /*y coordinate */ + int p; /* pressure */ + int flag; /* touch event flag: 0 -- down; 1-- up; 2 -- contact */ + int id; /*touch ID */ + int area; +}; + +struct fts_ts_data { + struct i2c_client *client; + struct input_dev *input_dev; + struct regulator *vdd; + struct regulator *vcc_i2c; + spinlock_t irq_lock; + struct mutex report_mutex; + int irq; + bool irq_disabled; + bool power_disabled; + + /* multi-touch */ + struct ts_event *events; + u32 max_touch_number; + u8 *point_buf; + int pnt_buf_size; + int touches; + int touch_point; + int point_num; + bool dev_pm_suspend; + bool low_power_mode; + struct completion dev_pm_suspend_completion; + struct pinctrl *pinctrl; + + // DT data + struct gpio_desc *irq_gpio; + struct gpio_desc *reset_gpio; + u32 width; + u32 height; +}; + +int fts_i2c_read(struct i2c_client *client, char *writebuf, int writelen, + char *readbuf, int readlen) +{ + int ret = 0; + int msg_count = !!writelen + 1; + struct i2c_msg msgs[2]; + + if (readlen < 0 || writelen < 0) + return -EINVAL; + + // If writelen is zero then only populate msgs[0]. + // otherwise we read into msgs[1] + msgs[msg_count-1].len = readlen; + msgs[msg_count-1].buf = readbuf; + msgs[msg_count-1].addr = client->addr; + msgs[msg_count-1].flags = I2C_M_RD; + + if (writelen > 0) { + msgs[0].len = writelen; + msgs[0].buf = writebuf; + msgs[0].addr = client->addr; + msgs[0].flags = 0; + } + + mutex_lock(&i2c_rw_access); + + ret = i2c_transfer(client->adapter, msgs, msg_count); + + mutex_unlock(&i2c_rw_access); + return ret; +} + +int fts_i2c_read_reg(struct i2c_client *client, u8 regaddr, u8 *regvalue) +{ + return fts_i2c_read(client, &regaddr, 1, regvalue, 1); +} + +static bool fts_chip_is_valid(struct fts_ts_data *data, u16 id) +{ + if (id != CHIP_TYPE_5452 && id != CHIP_TYPE_8719) + return false; + + return true; +} + +int fts_wait_ready(struct fts_ts_data *data) +{ + int ret = 0; + int cnt = 0; + u8 reg_value[2]; + struct i2c_client *client = data->client; + + do { + ret = fts_i2c_read_reg(client, FTS_REG_CHIP_ID, &reg_value[0]); + ret = fts_i2c_read_reg(client, FTS_REG_CHIP_ID2, &reg_value[1]); + if (fts_chip_is_valid(data, reg_value[0] << 8 | reg_value[1])) { + dev_dbg(&data->client->dev, "TP Ready, Device ID = 0x%x%x, count = %d", + reg_value[0], reg_value[1], cnt); + return 0; + } + cnt++; + msleep(INTERVAL_READ_REG); + } while ((cnt * INTERVAL_READ_REG) < TIMEOUT_READ_REG); + + return -EIO; +} + +static int fts_power_source_init(struct fts_ts_data *data) +{ + int ret = 0; + + data->vdd = devm_regulator_get(&data->client->dev, "vdd"); + if (IS_ERR_OR_NULL(data->vdd)) { + ret = PTR_ERR(data->vdd); + dev_err(&data->client->dev, "get vdd regulator failed,ret=%d", ret); + return ret; + } + + if (regulator_count_voltages(data->vdd) > 0) { + ret = regulator_set_voltage(data->vdd, FTS_VDD_MIN_UV, + FTS_VDD_MAX_UV); + if (ret < 0) { + dev_err(&data->client->dev, "failed to set vdd regulator ret=%d", ret); + goto exit; + } + } + + data->vcc_i2c = devm_regulator_get(&data->client->dev, "vcc-i2c"); + if (IS_ERR(data->vcc_i2c)) { + ret = PTR_ERR(data->vcc_i2c); + dev_err(&data->client->dev, "get vcc_i2c regulator failed,ret=%d", ret); + return ret; + } + + if (regulator_count_voltages(data->vcc_i2c) > 0) { + ret = regulator_set_voltage(data->vcc_i2c, FTS_I2C_VCC_MIN_UV, + FTS_I2C_VCC_MAX_UV); + if (ret < 0) { + dev_err(&data->client->dev, "failed to set vcc_i2c regulator ret=%d", + ret); + goto exit; + } + } + +exit: + return ret; +} + +static int fts_power_source_release(struct fts_ts_data *data) +{ + if (!data->power_disabled) { + regulator_disable(data->vdd); + regulator_disable(data->vcc_i2c); + } + + devm_regulator_put(data->vdd); + devm_regulator_put(data->vcc_i2c); + + return 0; +} + +static int fts_power_source_ctrl(struct fts_ts_data *data, bool enable) +{ + int ret = 0; + + if (enable) { + if (data->power_disabled) { + ret = regulator_enable(data->vdd); + if (ret < 0) { + dev_err(&data->client->dev, + "enable vdd regulator failed,ret=%d", + ret); + } + + ret = regulator_enable(data->vcc_i2c); + if (ret < 0) { + dev_err(&data->client->dev, "enable vcc_i2c regulator failed,ret=%d", + ret); + } + data->power_disabled = false; + } + } else { + if (!data->power_disabled) { + ret = regulator_disable(data->vdd); + if (ret < 0) { + dev_err(&data->client->dev, + "disable vdd regulator failed,ret=%d", + ret); + } + + ret = regulator_disable(data->vcc_i2c); + if (ret < 0) { + dev_err(&data->client->dev, "disable vcc_i2c regulator failed,ret=%d", + ret); + } + + data->power_disabled = true; + } + } + + return ret; +} + +static int fts_pinctrl_set_active(struct fts_ts_data *data, bool enable) +{ + int ret = 0; + struct pinctrl_state *state = pinctrl_lookup_state(data->pinctrl, + enable ? "default" : "suspend"); + + if (IS_ERR_OR_NULL(state)) { + dev_err(&data->client->dev, "pinctrl lookup %s failed\n", + enable ? "default" : "suspend"); + return -EINVAL; + } + + ret = pinctrl_select_state(data->pinctrl, state); + if (ret < 0) { + dev_err(&data->client->dev, + "Failed to set pinctrl state: enable = %d, ret = %d", + enable, ret); + } + + return ret; +} + +static void fts_release_all_finger(struct fts_ts_data *data) +{ + struct input_dev *input_dev = data->input_dev; + u32 finger_count = 0; + + mutex_lock(&data->report_mutex); + + for (finger_count = 0; finger_count < data->max_touch_number; + finger_count++) { + input_mt_slot(input_dev, finger_count); + input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, false); + } + + input_report_key(input_dev, BTN_TOUCH, 0); + input_sync(input_dev); + + mutex_unlock(&data->report_mutex); +} + +static int fts_input_report_b(struct fts_ts_data *data) +{ + int i = 0; + int uppoint = 0; + int touches = 0; + bool va_reported = false; + struct ts_event *events = data->events; + + for (i = 0; i < data->touch_point; i++) { + if (events[i].id >= data->max_touch_number) + break; + + va_reported = true; + input_mt_slot(data->input_dev, events[i].id); + + if (events[i].flag == FTS_TOUCH_DOWN || events[i].flag == FTS_TOUCH_CONTACT) { + input_mt_report_slot_state(data->input_dev, + MT_TOOL_FINGER, true); + + if (events[i].p <= 0) + events[i].p = 0x3f; + + input_report_abs(data->input_dev, ABS_MT_PRESSURE, + events[i].p); + + if (events[i].area <= 0) + events[i].area = 0x09; + + input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, + events[i].area); + input_report_abs(data->input_dev, ABS_MT_POSITION_X, + events[i].x); + input_report_abs(data->input_dev, ABS_MT_POSITION_Y, + events[i].y); + + touches |= BIT(events[i].id); + data->touches |= BIT(events[i].id); + } else { + uppoint++; + + input_report_abs(data->input_dev, ABS_MT_PRESSURE, 0); + + input_mt_report_slot_state(data->input_dev, + MT_TOOL_FINGER, false); + data->touches &= ~BIT(events[i].id); + } + } + + if (data->touches ^ touches) { + for (i = 0; i < data->max_touch_number; i++) { + if (BIT(i) & (data->touches ^ touches)) { + va_reported = true; + input_mt_slot(data->input_dev, i); + input_mt_report_slot_state( + data->input_dev, MT_TOOL_FINGER, false); + } + } + } + data->touches = touches; + + if (va_reported) { + if (!data->point_num || !touches) + input_report_key(data->input_dev, BTN_TOUCH, 0); + else + input_report_key(data->input_dev, BTN_TOUCH, 1); + } else { + dev_err(&data->client->dev, "va not reported, but touches=%d", touches); + } + + input_sync(data->input_dev); + return 0; +} + +static int fts_read_touchdata(struct fts_ts_data *data) +{ + int ret = 0; + int i = 0; + u8 pointid; + int base; + struct ts_event *events = data->events; + int max_touch_num = data->max_touch_number; + u8 *buf = data->point_buf; + + data->point_num = 0; + data->touch_point = 0; + + memset(buf, 0xFF, data->pnt_buf_size); + buf[0] = 0x00; + + ret = fts_i2c_read(data->client, buf, 1, buf, data->pnt_buf_size); + if (ret < 0) { + dev_err(&data->client->dev, "read touchdata failed, ret:%d", ret); + return ret; + } + data->point_num = buf[FTS_TOUCH_POINT_NUM] & 0x0F; + + if (data->point_num > max_touch_num) + return -EINVAL; + + for (i = 0; i < max_touch_num; i++) { + base = FTS_ONE_TCH_LEN * i; + + pointid = (buf[FTS_TOUCH_ID_POS + base]) >> 4; + if (pointid >= FTS_MAX_ID) + break; + + else if (pointid >= max_touch_num) + return -EINVAL; + + data->touch_point++; + + events[i].x = ((buf[FTS_TOUCH_X_H_POS + base] & 0x0F) << 8) + + (buf[FTS_TOUCH_X_L_POS + base] & 0xFF); + events[i].y = ((buf[FTS_TOUCH_Y_H_POS + base] & 0x0F) << 8) + + (buf[FTS_TOUCH_Y_L_POS + base] & 0xFF); + events[i].flag = buf[FTS_TOUCH_EVENT_POS + base] >> 6; + events[i].id = buf[FTS_TOUCH_ID_POS + base] >> 4; + events[i].area = buf[FTS_TOUCH_AREA_POS + base] >> 4; + events[i].p = buf[FTS_TOUCH_PRE_POS + base]; + + if (((events[i].flag == FTS_TOUCH_DOWN) || (events[i].flag == FTS_TOUCH_CONTACT)) + && (data->point_num == 0)) { + dev_err(&data->client->dev, "abnormal touch data from fw"); + return -EIO; + } + } + if (data->touch_point == 0) { + dev_err(&data->client->dev, "no touch point information"); + return -EIO; + } + + return 0; +} + +static void fts_report_event(struct fts_ts_data *data) +{ + fts_input_report_b(data); +} + +static irqreturn_t fts_ts_interrupt(int irq, void *d) +{ + int ret = 0; + struct fts_ts_data *data = (struct fts_ts_data *)d; + + if (!data) { + dev_err(&data->client->dev, "%s() Invalid fts_ts_data", __func__); + return IRQ_HANDLED; + } + + if (data->dev_pm_suspend) { + ret = wait_for_completion_timeout( + &data->dev_pm_suspend_completion, + msecs_to_jiffies(700)); + if (!ret) { + dev_err(&data->client->dev, + "Didn't resume in time, skipping wakeup event handling\n"); + return IRQ_HANDLED; + } + } + + ret = fts_read_touchdata(data); + if (ret == 0) { + mutex_lock(&data->report_mutex); + fts_report_event(data); + mutex_unlock(&data->report_mutex); + } + + return IRQ_HANDLED; +} + +static int fts_input_init(struct fts_ts_data *data) +{ + int ret = 0; + struct input_dev *input_dev; + + input_dev = input_allocate_device(); + if (!input_dev) { + dev_err(&data->client->dev, "Failed to allocate memory for input device"); + return -ENOMEM; + } + + /* Init and register Input device */ + input_dev->name = FTS_DRIVER_NAME; + input_dev->id.bustype = BUS_I2C; + input_dev->dev.parent = &data->client->dev; + + input_set_drvdata(input_dev, data); + + __set_bit(EV_SYN, input_dev->evbit); + __set_bit(EV_ABS, input_dev->evbit); + __set_bit(BTN_TOUCH, input_dev->keybit); + __set_bit(INPUT_PROP_DIRECT, input_dev->propbit); + + input_mt_init_slots(input_dev, data->max_touch_number, + INPUT_MT_DIRECT); + + input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, + data->width - 1, 0, 0); + input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, + data->height - 1, 0, 0); + input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 0xFF, 0, 0); + + input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 0xFF, 0, 0); + + data->pnt_buf_size = data->max_touch_number * FTS_ONE_TCH_LEN + 3; + data->point_buf = devm_kzalloc(&data->client->dev, data->pnt_buf_size, GFP_KERNEL); + if (!data->point_buf) { + dev_err(&data->client->dev, "Failed to alloc memory for point buf!"); + ret = -ENOMEM; + goto err_out; + } + + data->events = devm_kzalloc(&data->client->dev, + data->max_touch_number * sizeof(struct ts_event), GFP_KERNEL); + if (!data->events) { + ret = -ENOMEM; + goto err_out; + } + ret = input_register_device(input_dev); + if (ret < 0) { + dev_err(&data->client->dev, "Input device registration failed"); + goto err_out; + } + + data->input_dev = input_dev; + + return 0; + +err_out: + input_set_drvdata(input_dev, NULL); + input_free_device(input_dev); + input_dev = NULL; + + return ret; +} + +static int fts_reset(struct fts_ts_data *data) +{ + gpiod_set_value_cansleep(data->reset_gpio, 0); + msleep(20); + gpiod_set_value_cansleep(data->reset_gpio, 1); + + return 0; +} + +static int fts_parse_dt(struct fts_ts_data *data) +{ + int ret = 0; + struct device *dev = &data->client->dev; + struct device_node *np = dev->of_node; + u32 val; + + ret = of_property_read_u32(np, "touchscreen-size-x", &data->width); + if (ret < 0) { + dev_err(&data->client->dev, "Unable to read property 'touchscreen-size-x'"); + return -EINVAL; + } + + ret = of_property_read_u32(np, "touchscreen-size-y", &data->height); + if (ret < 0) { + dev_err(&data->client->dev, "Unable to read property 'touchscreen-size-y'"); + return -EINVAL; + } + + ret = of_property_read_u32(np, "focaltech,max-touch-number", &val); + if (ret < 0) { + dev_err(&data->client->dev, "Unable to read property 'focaltech,max-touch-number'"); + return -EINVAL; + } + if (val < 2 || val > FTS_MAX_POINTS_SUPPORT) { + dev_err(&data->client->dev, "'focaltech,max-touch-number' out of range [2, %d]", + FTS_MAX_POINTS_SUPPORT); + return -EINVAL; + } + data->max_touch_number = val; + + data->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW); + if (data->reset_gpio < 0) { + dev_err(&data->client->dev, "Unable to get reset gpio"); + return -EINVAL; + } + + data->irq_gpio = devm_gpiod_get_optional(dev, "irq", GPIOD_OUT_LOW); + + return 0; +} + +static int fts_ts_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + int ret = 0; + struct fts_ts_data *data; + struct pinctrl_state *pinctrl_state_temp; + + if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { + dev_err(&data->client->dev, "I2C not supported"); + return -ENODEV; + } + + data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); + if (!data) + return -ENOMEM; + + data->client = client; + ret = fts_parse_dt(data); + if (ret < 0) + return ret; + + i2c_set_clientdata(client, data); + + spin_lock_init(&data->irq_lock); + mutex_init(&data->report_mutex); + + ret = fts_input_init(data); + if (ret < 0) { + dev_err(&data->client->dev, "Input initialization fail"); + goto err_input_init; + } + + ret = fts_power_source_init(data); + if (ret < 0) { + dev_err(&data->client->dev, "fail to get vdd/vcc_i2c regulator"); + goto err_power_init; + } + + data->power_disabled = true; + ret = fts_power_source_ctrl(data, true); + if (ret < 0) { + dev_err(&data->client->dev, "fail to enable vdd/vcc_i2c regulator"); + goto err_power_ctrl; + } + + data->pinctrl = devm_pinctrl_get(&client->dev); + if (IS_ERR_OR_NULL(data->pinctrl)) { + dev_err(&data->client->dev, "Failed to get pinctrl, please check dts"); + ret = PTR_ERR(data->pinctrl); + goto err_power_ctrl; + } + + pinctrl_state_temp = pinctrl_lookup_state(data->pinctrl, "default"); + if (IS_ERR_OR_NULL(pinctrl_state_temp) || + IS_ERR_OR_NULL(pinctrl_lookup_state(data->pinctrl, "suspend"))) { + dev_err(&data->client->dev, "Failed to get default or suspend pinctrl state, please check dts"); + goto err_power_ctrl; + } + + fts_pinctrl_set_active(data, true); + + ret = fts_reset(data); + if (ret < 0) { + dev_err(&data->client->dev, "Failed to reset chip"); + goto err_gpio_config; + } + + ret = fts_wait_ready(data); + if (ret < 0) { + dev_err(&data->client->dev, "Touch IC didn't turn on or is unsupported"); + goto err_gpio_config; + } + + if (data->irq_gpio) { + data->irq = gpiod_to_irq(data->irq_gpio); + + ret = request_threaded_irq(data->irq, NULL, fts_ts_interrupt, + IRQF_ONESHOT, + data->client->name, data); + if (ret < 0) { + dev_err(&data->client->dev, "request irq failed"); + goto err_gpio_config; + } + device_init_wakeup(&client->dev, true); + } + + data->dev_pm_suspend = false; + init_completion(&data->dev_pm_suspend_completion); + + return 0; + +err_gpio_config: + fts_power_source_ctrl(data, false); +err_power_ctrl: + fts_power_source_release(data); +err_power_init: + input_unregister_device(data->input_dev); +err_input_init: + devm_kfree(&client->dev, data); + + return ret; +} + +static int fts_ts_remove(struct i2c_client *client) +{ + struct fts_ts_data *data = i2c_get_clientdata(client); + + free_irq(client->irq, data); + input_unregister_device(data->input_dev); + + fts_power_source_ctrl(data, false); + fts_power_source_release(data); + + kfree(data->point_buf); + kfree(data->events); + + devm_kfree(&client->dev, data); + + return 0; +} + +static int fts_ts_suspend(struct device *dev) +{ + struct fts_ts_data *data = dev_get_drvdata(dev); + int ret = 0; + + disable_irq(data->irq); + + ret = fts_power_source_ctrl(data, false); + if (ret < 0) + dev_err(dev, "power off fail, ret=%d", ret); + fts_pinctrl_set_active(data, false); + + return 0; +} + +static int fts_ts_resume(struct device *dev) +{ + struct fts_ts_data *data = dev_get_drvdata(dev); + + fts_release_all_finger(data); + + fts_power_source_ctrl(data, true); + fts_pinctrl_set_active(data, true); + + fts_wait_ready(data); + + enable_irq(data->irq); + + return 0; +} + +static int fts_pm_suspend(struct device *dev) +{ + struct fts_ts_data *data = dev_get_drvdata(dev); + int ret = 0; + + data->dev_pm_suspend = true; + + if (data->low_power_mode) { + ret = enable_irq_wake(data->irq); + if (ret < 0) { + dev_err(&data->client->dev, "enable_irq_wake(irq:%d) failed", + data->irq); + } + } else { + ret = fts_ts_suspend(dev); + } + + reinit_completion(&data->dev_pm_suspend_completion); + + return ret; +} + +static int fts_pm_resume(struct device *dev) +{ + struct fts_ts_data *data = dev_get_drvdata(dev); + int ret = 0; + + data->dev_pm_suspend = false; + + if (data->low_power_mode) { + ret = disable_irq_wake(data->irq); + if (ret < 0) { + dev_err(&data->client->dev, "disable_irq_wake(irq:%d) failed", + data->irq); + } + } else { + ret = fts_ts_resume(dev); + } + + complete(&data->dev_pm_suspend_completion); + + return 0; +} + +static const struct dev_pm_ops fts_dev_pm_ops = { + .suspend = fts_pm_suspend, + .resume = fts_pm_resume, +}; + +static const struct of_device_id fts_match_table[] = { + { .compatible = "focaltech,fts5452", }, + { .compatible = "focaltech,fts8719", }, + { /* sentinel */ }, +}; + +MODULE_DEVICE_TABLE(of, fts_match_table); + +static struct i2c_driver fts_ts_driver = { + .probe = fts_ts_probe, + .remove = fts_ts_remove, + .driver = { + .name = FTS_DRIVER_NAME, + .pm = &fts_dev_pm_ops, + .of_match_table = fts_match_table, + }, +}; +module_i2c_driver(fts_ts_driver); + +MODULE_AUTHOR("Caleb Connolly caleb@connolly.tech"); +MODULE_DESCRIPTION("FocalTech touchscreen Driver"); +MODULE_LICENSE("GPL v2"); -- 2.34.1